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

   1 package net.sourceforge.phpeclipse.phpeditor;
   2
   3 /**********************************************************************
   4  Copyright (c) 2000, 2002 IBM Corp. and others.
   5  All rights reserved. This program and the accompanying materials
   6  are made available under the terms of the Common Public License v1.0
   7  which accompanies this distribution, and is available at
   8  http://www.eclipse.org/legal/cpl-v10.html
   9
  10  Contributors:
  11  IBM Corporation - Initial implementation
  12  Klaus Hartlage - www.eclipseproject.de
  13  **********************************************************************/
  14 import java.util.ArrayList;
  15 import java.util.HashMap;
  16 import java.util.Iterator;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.ResourceBundle;
  20 import java.util.StringTokenizer;
  21
  22 import net.sourceforge.phpdt.core.ICompilationUnit;
  23 import net.sourceforge.phpdt.core.IImportContainer;
  24 import net.sourceforge.phpdt.core.IImportDeclaration;
  25 import net.sourceforge.phpdt.core.IJavaElement;
  26 import net.sourceforge.phpdt.core.IJavaProject;
  27 import net.sourceforge.phpdt.core.IMember;
  28 import net.sourceforge.phpdt.core.ISourceRange;
  29 import net.sourceforge.phpdt.core.ISourceReference;
  30 import net.sourceforge.phpdt.core.JavaCore;
  31 import net.sourceforge.phpdt.core.JavaModelException;
  32 import net.sourceforge.phpdt.internal.ui.actions.CompositeActionGroup;
  33 import net.sourceforge.phpdt.internal.ui.actions.FoldingActionGroup;
  34 import net.sourceforge.phpdt.internal.ui.text.CustomSourceInformationControl;
  35 import net.sourceforge.phpdt.internal.ui.text.HTMLTextPresenter;
  36 import net.sourceforge.phpdt.internal.ui.text.IPHPPartitions;
  37 import net.sourceforge.phpdt.internal.ui.text.PHPPairMatcher;
  38 import net.sourceforge.phpdt.internal.ui.text.PreferencesAdapter;
  39 import net.sourceforge.phpdt.internal.ui.viewsupport.IViewPartInputProvider;
  40 import net.sourceforge.phpdt.ui.IContextMenuConstants;
  41 import net.sourceforge.phpdt.ui.JavaUI;
  42 import net.sourceforge.phpdt.ui.PreferenceConstants;
  43 import net.sourceforge.phpdt.ui.actions.GotoMatchingBracketAction;
  44 import net.sourceforge.phpdt.ui.text.JavaTextTools;
  45 import net.sourceforge.phpdt.ui.text.PHPSourceViewerConfiguration;
  46 import net.sourceforge.phpdt.ui.text.folding.IJavaFoldingStructureProvider;
  47 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  48
  49 import org.eclipse.core.resources.IMarker;
  50 import org.eclipse.core.resources.IResource;
  51 import org.eclipse.core.runtime.CoreException;
  52 import org.eclipse.core.runtime.IProgressMonitor;
  53 import org.eclipse.core.runtime.IStatus;
  54 import org.eclipse.core.runtime.Preferences;
  55 import org.eclipse.core.runtime.Status;
  56 import org.eclipse.core.runtime.jobs.Job;
  57 import org.eclipse.jface.action.Action;
  58 import org.eclipse.jface.action.GroupMarker;
  59 import org.eclipse.jface.action.IAction;
  60 import org.eclipse.jface.action.MenuManager;
  61 import org.eclipse.jface.action.Separator;
  62 import org.eclipse.jface.preference.IPreferenceStore;
  63 import org.eclipse.jface.preference.PreferenceConverter;
  64 import org.eclipse.jface.text.BadLocationException;
  65 import org.eclipse.jface.text.DefaultInformationControl;
  66 import org.eclipse.jface.text.DocumentEvent;
  67 import org.eclipse.jface.text.IDocument;
  68 import org.eclipse.jface.text.IDocumentListener;
  69 import org.eclipse.jface.text.IInformationControl;
  70 import org.eclipse.jface.text.IInformationControlCreator;
  71 import org.eclipse.jface.text.IRegion;
  72 import org.eclipse.jface.text.ITextHover;
  73 import org.eclipse.jface.text.ITextInputListener;
  74 import org.eclipse.jface.text.ITextSelection;
  75 import org.eclipse.jface.text.ITextViewer;
  76 import org.eclipse.jface.text.ITextViewerExtension2;
  77 import org.eclipse.jface.text.ITextViewerExtension3;
  78 import org.eclipse.jface.text.ITextViewerExtension5;
  79 import org.eclipse.jface.text.ITypedRegion;
  80 import org.eclipse.jface.text.Position;
  81 import org.eclipse.jface.text.Region;
  82 import org.eclipse.jface.text.TextSelection;
  83 import org.eclipse.jface.text.information.IInformationProvider;
  84 import org.eclipse.jface.text.information.InformationPresenter;
  85 import org.eclipse.jface.text.reconciler.IReconciler;
  86 import org.eclipse.jface.text.source.Annotation;
  87 import org.eclipse.jface.text.source.IAnnotationModel;
  88 import org.eclipse.jface.text.source.IAnnotationModelExtension;
  89 import org.eclipse.jface.text.source.IOverviewRuler;
  90 import org.eclipse.jface.text.source.ISourceViewer;
  91 import org.eclipse.jface.text.source.IVerticalRuler;
  92 import org.eclipse.jface.text.source.OverviewRuler;
  93 import org.eclipse.jface.text.source.SourceViewerConfiguration;
  94 import org.eclipse.jface.text.source.projection.ProjectionSupport;
  95 import org.eclipse.jface.text.source.projection.ProjectionViewer;
  96 import org.eclipse.jface.util.IPropertyChangeListener;
  97 import org.eclipse.jface.util.ListenerList;
  98 import org.eclipse.jface.util.PropertyChangeEvent;
  99 import org.eclipse.jface.viewers.IPostSelectionProvider;
 100 import org.eclipse.jface.viewers.ISelection;
 101 import org.eclipse.jface.viewers.ISelectionChangedListener;
 102 import org.eclipse.jface.viewers.ISelectionProvider;
 103 import org.eclipse.jface.viewers.IStructuredSelection;
 104 import org.eclipse.jface.viewers.SelectionChangedEvent;
 105 import org.eclipse.jface.viewers.StructuredSelection;
 106 import org.eclipse.swt.SWT;
 107 import org.eclipse.swt.custom.BidiSegmentEvent;
 108 import org.eclipse.swt.custom.BidiSegmentListener;
 109 import org.eclipse.swt.custom.StyleRange;
 110 import org.eclipse.swt.custom.StyledText;
 111 import org.eclipse.swt.events.FocusEvent;
 112 import org.eclipse.swt.events.FocusListener;
 113 import org.eclipse.swt.events.KeyEvent;
 114 import org.eclipse.swt.events.KeyListener;
 115 import org.eclipse.swt.events.MouseEvent;
 116 import org.eclipse.swt.events.MouseListener;
 117 import org.eclipse.swt.events.MouseMoveListener;
 118 import org.eclipse.swt.events.PaintEvent;
 119 import org.eclipse.swt.events.PaintListener;
 120 import org.eclipse.swt.graphics.Color;
 121 import org.eclipse.swt.graphics.Cursor;
 122 import org.eclipse.swt.graphics.GC;
 123 import org.eclipse.swt.graphics.Image;
 124 import org.eclipse.swt.graphics.Point;
 125 import org.eclipse.swt.graphics.RGB;
 126 import org.eclipse.swt.widgets.Composite;
 127 import org.eclipse.swt.widgets.Control;
 128 import org.eclipse.swt.widgets.Display;
 129 import org.eclipse.swt.widgets.Shell;
 130 import org.eclipse.ui.IEditorInput;
 131 import org.eclipse.ui.IPageLayout;
 132 import org.eclipse.ui.IPartService;
 133 import org.eclipse.ui.IViewPart;
 134 import org.eclipse.ui.IWorkbenchPage;
 135 import org.eclipse.ui.IWorkbenchPart;
 136 import org.eclipse.ui.IWorkbenchWindow;
 137 import org.eclipse.ui.actions.ActionContext;
 138 import org.eclipse.ui.actions.ActionGroup;
 139 import org.eclipse.ui.editors.text.DefaultEncodingSupport;
 140 import org.eclipse.ui.editors.text.EditorsUI;
 141 import org.eclipse.ui.editors.text.IEncodingSupport;
 142 import org.eclipse.ui.part.IShowInTargetList;
 143 import org.eclipse.ui.texteditor.AbstractDecoratedTextEditor;
 144 import org.eclipse.ui.texteditor.ChainedPreferenceStore;
 145 import org.eclipse.ui.texteditor.DefaultRangeIndicator;
 146 import org.eclipse.ui.texteditor.IDocumentProvider;
 147 import org.eclipse.ui.texteditor.IEditorStatusLine;
 148 import org.eclipse.ui.texteditor.ITextEditorActionConstants;
 149 import org.eclipse.ui.texteditor.MarkerAnnotation;
 150 import org.eclipse.ui.texteditor.ResourceAction;
 151 import org.eclipse.ui.texteditor.SourceViewerDecorationSupport;
 152 import org.eclipse.ui.texteditor.TextEditorAction;
 153 import org.eclipse.ui.texteditor.TextOperationAction;
 154 import org.eclipse.ui.views.contentoutline.ContentOutline;
 155 import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
 156 import org.eclipse.ui.views.tasklist.TaskList;
 157
 158 /**
 159  * PHP specific text editor.
 160  */
 161 public abstract class PHPEditor extends AbstractDecoratedTextEditor implements IViewPartInputProvider {
 162   //extends StatusTextEditor implements IViewPartInputProvider { // extends
 163   // TextEditor {
 164
 165   /**
 166    * Internal implementation class for a change listener.
 167    *
 168    * @since 3.0
 169    */
 170   protected abstract class AbstractSelectionChangedListener implements ISelectionChangedListener {
 171
 172     /**
 173      * Installs this selection changed listener with the given selection provider. If the selection provider is a post selection
 174      * provider, post selection changed events are the preferred choice, otherwise normal selection changed events are requested.
 175      *
 176      * @param selectionProvider
 177      */
 178     public void install(ISelectionProvider selectionProvider) {
 179       if (selectionProvider == null)
 180         return;
 181
 182       if (selectionProvider instanceof IPostSelectionProvider) {
 183         IPostSelectionProvider provider = (IPostSelectionProvider) selectionProvider;
 184         provider.addPostSelectionChangedListener(this);
 185       } else {
 186         selectionProvider.addSelectionChangedListener(this);
 187       }
 188     }
 189
 190     /**
 191      * Removes this selection changed listener from the given selection provider.
 192      *
 193      * @param selectionProvider
 194      *          the selection provider
 195      */
 196     public void uninstall(ISelectionProvider selectionProvider) {
 197       if (selectionProvider == null)
 198         return;
 199
 200       if (selectionProvider instanceof IPostSelectionProvider) {
 201         IPostSelectionProvider provider = (IPostSelectionProvider) selectionProvider;
 202         provider.removePostSelectionChangedListener(this);
 203       } else {
 204         selectionProvider.removeSelectionChangedListener(this);
 205       }
 206     }
 207   }
 208
 209   /**
 210    * Updates the Java outline page selection and this editor's range indicator.
 211    *
 212    * @since 3.0
 213    */
 214   private class EditorSelectionChangedListener extends AbstractSelectionChangedListener {
 215
 216     /*
 217      * @see org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent)
 218      */
 219     public void selectionChanged(SelectionChangedEvent event) {
 220       // XXX: see https://bugs.eclipse.org/bugs/show_bug.cgi?id=56161
 221       PHPEditor.this.selectionChanged();
 222     }
 223   }
 224
 225   /**
 226    * "Smart" runnable for updating the outline page's selection.
 227    */
 228   class OutlinePageSelectionUpdater implements Runnable {
 229
 230     /** Has the runnable already been posted? */
 231     private boolean fPosted = false;
 232
 233     public OutlinePageSelectionUpdater() {
 234     }
 235
 236     /*
 237      * @see Runnable#run()
 238      */
 239     public void run() {
 240       synchronizeOutlinePageSelection();
 241       fPosted = false;
 242     }
 243
 244     /**
 245      * Posts this runnable into the event queue.
 246      */
 247     public void post() {
 248       if (fPosted)
 249         return;
 250
 251       Shell shell = getSite().getShell();
 252       if (shell != null & !shell.isDisposed()) {
 253         fPosted = true;
 254         shell.getDisplay().asyncExec(this);
 255       }
 256     }
 257   };
 258
 259   class SelectionChangedListener implements ISelectionChangedListener {
 260     public void selectionChanged(SelectionChangedEvent event) {
 261       doSelectionChanged(event);
 262     }
 263   };
 264
 265   /**
 266    * Adapts an options {@link java.util.Map}to {@link org.eclipse.jface.preference.IPreferenceStore}.
 267    * <p>
 268    * This preference store is read-only i.e. write access throws an {@link java.lang.UnsupportedOperationException}.
 269    * </p>
 270    *
 271    * @since 3.0
 272    */
 273   private static class OptionsAdapter implements IPreferenceStore {
 274
 275     /**
 276      * A property change event filter.
 277      */
 278     public interface IPropertyChangeEventFilter {
 279
 280       /**
 281        * Should the given event be filtered?
 282        *
 283        * @param event
 284        *          The property change event.
 285        * @return <code>true</code> iff the given event should be filtered.
 286        */
 287       public boolean isFiltered(PropertyChangeEvent event);
 288
 289     }
 290
 291     /**
 292      * Property change listener. Listens for events in the options Map and fires a
 293      * {@link org.eclipse.jface.util.PropertyChangeEvent}on this adapter with arguments from the received event.
 294      */
 295     private class PropertyChangeListener implements IPropertyChangeListener {
 296
 297       /**
 298        * {@inheritDoc}
 299        */
 300       public void propertyChange(PropertyChangeEvent event) {
 301         if (getFilter().isFiltered(event))
 302           return;
 303
 304         if (event.getNewValue() == null)
 305           fOptions.remove(event.getProperty());
 306         else
 307           fOptions.put(event.getProperty(), event.getNewValue());
 308
 309         firePropertyChangeEvent(event.getProperty(), event.getOldValue(), event.getNewValue());
 310       }
 311     }
 312
 313     /** Listeners on this adapter */
 314     private ListenerList fListeners = new ListenerList();
 315
 316     /** Listener on the adapted options Map */
 317     private IPropertyChangeListener fListener = new PropertyChangeListener();
 318
 319     /** Adapted options Map */
 320     private Map fOptions;
 321
 322     /** Preference store through which events are received. */
 323     private IPreferenceStore fMockupPreferenceStore;
 324
 325     /** Property event filter. */
 326     private IPropertyChangeEventFilter fFilter;
 327
 328     /**
 329      * Initialize with the given options.
 330      *
 331      * @param options
 332      *          The options to wrap
 333      * @param mockupPreferenceStore
 334      *          the mock-up preference store
 335      * @param filter
 336      *          the property change filter
 337      */
 338     public OptionsAdapter(Map options, IPreferenceStore mockupPreferenceStore, IPropertyChangeEventFilter filter) {
 339       fMockupPreferenceStore = mockupPreferenceStore;
 340       fOptions = options;
 341       setFilter(filter);
 342     }
 343
 344     /**
 345      * {@inheritDoc}
 346      */
 347     public void addPropertyChangeListener(IPropertyChangeListener listener) {
 348       if (fListeners.size() == 0)
 349         fMockupPreferenceStore.addPropertyChangeListener(fListener);
 350       fListeners.add(listener);
 351     }
 352
 353     /**
 354      * {@inheritDoc}
 355      */
 356     public void removePropertyChangeListener(IPropertyChangeListener listener) {
 357       fListeners.remove(listener);
 358       if (fListeners.size() == 0)
 359         fMockupPreferenceStore.removePropertyChangeListener(fListener);
 360     }
 361
 362     /**
 363      * {@inheritDoc}
 364      */
 365     public boolean contains(String name) {
 366       return fOptions.containsKey(name);
 367     }
 368
 369     /**
 370      * {@inheritDoc}
 371      */
 372     public void firePropertyChangeEvent(String name, Object oldValue, Object newValue) {
 373       PropertyChangeEvent event = new PropertyChangeEvent(this, name, oldValue, newValue);
 374       Object[] listeners = fListeners.getListeners();
 375       for (int i = 0; i < listeners.length; i++)
 376         ((IPropertyChangeListener) listeners[i]).propertyChange(event);
 377     }
 378
 379     /**
 380      * {@inheritDoc}
 381      */
 382     public boolean getBoolean(String name) {
 383       boolean value = BOOLEAN_DEFAULT_DEFAULT;
 384       String s = (String) fOptions.get(name);
 385       if (s != null)
 386         value = s.equals(TRUE);
 387       return value;
 388     }
 389
 390     /**
 391      * {@inheritDoc}
 392      */
 393     public boolean getDefaultBoolean(String name) {
 394       return BOOLEAN_DEFAULT_DEFAULT;
 395     }
 396
 397     /**
 398      * {@inheritDoc}
 399      */
 400     public double getDefaultDouble(String name) {
 401       return DOUBLE_DEFAULT_DEFAULT;
 402     }
 403
 404     /**
 405      * {@inheritDoc}
 406      */
 407     public float getDefaultFloat(String name) {
 408       return FLOAT_DEFAULT_DEFAULT;
 409     }
 410
 411     /**
 412      * {@inheritDoc}
 413      */
 414     public int getDefaultInt(String name) {
 415       return INT_DEFAULT_DEFAULT;
 416     }
 417
 418     /**
 419      * {@inheritDoc}
 420      */
 421     public long getDefaultLong(String name) {
 422       return LONG_DEFAULT_DEFAULT;
 423     }
 424
 425     /**
 426      * {@inheritDoc}
 427      */
 428     public String getDefaultString(String name) {
 429       return STRING_DEFAULT_DEFAULT;
 430     }
 431
 432     /**
 433      * {@inheritDoc}
 434      */
 435     public double getDouble(String name) {
 436       double value = DOUBLE_DEFAULT_DEFAULT;
 437       String s = (String) fOptions.get(name);
 438       if (s != null) {
 439         try {
 440           value = new Double(s).doubleValue();
 441         } catch (NumberFormatException e) {
 442         }
 443       }
 444       return value;
 445     }
 446
 447     /**
 448      * {@inheritDoc}
 449      */
 450     public float getFloat(String name) {
 451       float value = FLOAT_DEFAULT_DEFAULT;
 452       String s = (String) fOptions.get(name);
 453       if (s != null) {
 454         try {
 455           value = new Float(s).floatValue();
 456         } catch (NumberFormatException e) {
 457         }
 458       }
 459       return value;
 460     }
 461
 462     /**
 463      * {@inheritDoc}
 464      */
 465     public int getInt(String name) {
 466       int value = INT_DEFAULT_DEFAULT;
 467       String s = (String) fOptions.get(name);
 468       if (s != null) {
 469         try {
 470           value = new Integer(s).intValue();
 471         } catch (NumberFormatException e) {
 472         }
 473       }
 474       return value;
 475     }
 476
 477     /**
 478      * {@inheritDoc}
 479      */
 480     public long getLong(String name) {
 481       long value = LONG_DEFAULT_DEFAULT;
 482       String s = (String) fOptions.get(name);
 483       if (s != null) {
 484         try {
 485           value = new Long(s).longValue();
 486         } catch (NumberFormatException e) {
 487         }
 488       }
 489       return value;
 490     }
 491
 492     /**
 493      * {@inheritDoc}
 494      */
 495     public String getString(String name) {
 496       String value = (String) fOptions.get(name);
 497       if (value == null)
 498         value = STRING_DEFAULT_DEFAULT;
 499       return value;
 500     }
 501
 502     /**
 503      * {@inheritDoc}
 504      */
 505     public boolean isDefault(String name) {
 506       return false;
 507     }
 508
 509     /**
 510      * {@inheritDoc}
 511      */
 512     public boolean needsSaving() {
 513       return !fOptions.isEmpty();
 514     }
 515
 516     /**
 517      * {@inheritDoc}
 518      */
 519     public void putValue(String name, String value) {
 520       throw new UnsupportedOperationException();
 521     }
 522
 523     /**
 524      * {@inheritDoc}
 525      */
 526     public void setDefault(String name, double value) {
 527       throw new UnsupportedOperationException();
 528     }
 529
 530     /**
 531      * {@inheritDoc}
 532      */
 533     public void setDefault(String name, float value) {
 534       throw new UnsupportedOperationException();
 535     }
 536
 537     /**
 538      * {@inheritDoc}
 539      */
 540     public void setDefault(String name, int value) {
 541       throw new UnsupportedOperationException();
 542     }
 543
 544     /**
 545      * {@inheritDoc}
 546      */
 547     public void setDefault(String name, long value) {
 548       throw new UnsupportedOperationException();
 549     }
 550
 551     /**
 552      * {@inheritDoc}
 553      */
 554     public void setDefault(String name, String defaultObject) {
 555       throw new UnsupportedOperationException();
 556     }
 557
 558     /**
 559      * {@inheritDoc}
 560      */
 561     public void setDefault(String name, boolean value) {
 562       throw new UnsupportedOperationException();
 563     }
 564
 565     /**
 566      * {@inheritDoc}
 567      */
 568     public void setToDefault(String name) {
 569       throw new UnsupportedOperationException();
 570     }
 571
 572     /**
 573      * {@inheritDoc}
 574      */
 575     public void setValue(String name, double value) {
 576       throw new UnsupportedOperationException();
 577     }
 578
 579     /**
 580      * {@inheritDoc}
 581      */
 582     public void setValue(String name, float value) {
 583       throw new UnsupportedOperationException();
 584     }
 585
 586     /**
 587      * {@inheritDoc}
 588      */
 589     public void setValue(String name, int value) {
 590       throw new UnsupportedOperationException();
 591     }
 592
 593     /**
 594      * {@inheritDoc}
 595      */
 596     public void setValue(String name, long value) {
 597       throw new UnsupportedOperationException();
 598     }
 599
 600     /**
 601      * {@inheritDoc}
 602      */
 603     public void setValue(String name, String value) {
 604       throw new UnsupportedOperationException();
 605     }
 606
 607     /**
 608      * {@inheritDoc}
 609      */
 610     public void setValue(String name, boolean value) {
 611       throw new UnsupportedOperationException();
 612     }
 613
 614     /**
 615      * Returns the adapted options Map.
 616      *
 617      * @return Returns the adapted options Map.
 618      */
 619     public Map getOptions() {
 620       return fOptions;
 621     }
 622
 623     /**
 624      * Returns the mock-up preference store, events are received through this preference store.
 625      *
 626      * @return Returns the mock-up preference store.
 627      */
 628     public IPreferenceStore getMockupPreferenceStore() {
 629       return fMockupPreferenceStore;
 630     }
 631
 632     /**
 633      * Set the event filter to the given filter.
 634      *
 635      * @param filter
 636      *          The new filter.
 637      */
 638     public void setFilter(IPropertyChangeEventFilter filter) {
 639       fFilter = filter;
 640     }
 641
 642     /**
 643      * Returns the event filter.
 644      *
 645      * @return The event filter.
 646      */
 647     public IPropertyChangeEventFilter getFilter() {
 648       return fFilter;
 649     }
 650   }
 651
 652   /*
 653    * Link mode.
 654    */
 655   class MouseClickListener implements KeyListener, MouseListener, MouseMoveListener, FocusListener, PaintListener,
 656       IPropertyChangeListener, IDocumentListener, ITextInputListener {
 657
 658     /** The session is active. */
 659     private boolean fActive;
 660
 661     /** The currently active style range. */
 662     private IRegion fActiveRegion;
 663
 664     /** The currently active style range as position. */
 665     private Position fRememberedPosition;
 666
 667     /** The hand cursor. */
 668     private Cursor fCursor;
 669
 670     /** The link color. */
 671     private Color fColor;
 672
 673     /** The key modifier mask. */
 674     private int fKeyModifierMask;
 675
 676     public void deactivate() {
 677       deactivate(false);
 678     }
 679
 680     public void deactivate(boolean redrawAll) {
 681       if (!fActive)
 682         return;
 683
 684       repairRepresentation(redrawAll);
 685       fActive = false;
 686     }
 687
 688     public void install() {
 689
 690       ISourceViewer sourceViewer = getSourceViewer();
 691       if (sourceViewer == null)
 692         return;
 693
 694       StyledText text = sourceViewer.getTextWidget();
 695       if (text == null || text.isDisposed())
 696         return;
 697
 698       updateColor(sourceViewer);
 699
 700       sourceViewer.addTextInputListener(this);
 701
 702       IDocument document = sourceViewer.getDocument();
 703       if (document != null)
 704         document.addDocumentListener(this);
 705
 706       text.addKeyListener(this);
 707       text.addMouseListener(this);
 708       text.addMouseMoveListener(this);
 709       text.addFocusListener(this);
 710       text.addPaintListener(this);
 711
 712       updateKeyModifierMask();
 713
 714       IPreferenceStore preferenceStore = getPreferenceStore();
 715       preferenceStore.addPropertyChangeListener(this);
 716     }
 717
 718     private void updateKeyModifierMask() {
 719       String modifiers = getPreferenceStore().getString(BROWSER_LIKE_LINKS_KEY_MODIFIER);
 720       fKeyModifierMask = computeStateMask(modifiers);
 721       if (fKeyModifierMask == -1) {
 722         // Fallback to stored state mask
 723         fKeyModifierMask = getPreferenceStore().getInt(BROWSER_LIKE_LINKS_KEY_MODIFIER_MASK);
 724       }
 725       ;
 726     }
 727
 728     private int computeStateMask(String modifiers) {
 729       if (modifiers == null)
 730         return -1;
 731
 732       if (modifiers.length() == 0)
 733         return SWT.NONE;
 734
 735       int stateMask = 0;
 736       StringTokenizer modifierTokenizer = new StringTokenizer(modifiers, ",;.:+-* "); //$NON-NLS-1$
 737       while (modifierTokenizer.hasMoreTokens()) {
 738         int modifier = EditorUtility.findLocalizedModifier(modifierTokenizer.nextToken());
 739         if (modifier == 0 || (stateMask & modifier) == modifier)
 740           return -1;
 741         stateMask = stateMask | modifier;
 742       }
 743       return stateMask;
 744     }
 745
 746     public void uninstall() {
 747
 748       if (fColor != null) {
 749         fColor.dispose();
 750         fColor = null;
 751       }
 752
 753       if (fCursor != null) {
 754         fCursor.dispose();
 755         fCursor = null;
 756       }
 757
 758       ISourceViewer sourceViewer = getSourceViewer();
 759       if (sourceViewer == null)
 760         return;
 761
 762       sourceViewer.removeTextInputListener(this);
 763
 764       IDocument document = sourceViewer.getDocument();
 765       if (document != null)
 766         document.removeDocumentListener(this);
 767
 768       IPreferenceStore preferenceStore = getPreferenceStore();
 769       if (preferenceStore != null)
 770         preferenceStore.removePropertyChangeListener(this);
 771
 772       StyledText text = sourceViewer.getTextWidget();
 773       if (text == null || text.isDisposed())
 774         return;
 775
 776       text.removeKeyListener(this);
 777       text.removeMouseListener(this);
 778       text.removeMouseMoveListener(this);
 779       text.removeFocusListener(this);
 780       text.removePaintListener(this);
 781     }
 782
 783     /*
 784      * @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)
 785      */
 786     public void propertyChange(PropertyChangeEvent event) {
 787       if (event.getProperty().equals(PHPEditor.LINK_COLOR)) {
 788         ISourceViewer viewer = getSourceViewer();
 789         if (viewer != null)
 790           updateColor(viewer);
 791       } else if (event.getProperty().equals(BROWSER_LIKE_LINKS_KEY_MODIFIER)) {
 792         updateKeyModifierMask();
 793       }
 794     }
 795
 796     private void updateColor(ISourceViewer viewer) {
 797       if (fColor != null)
 798         fColor.dispose();
 799
 800       StyledText text = viewer.getTextWidget();
 801       if (text == null || text.isDisposed())
 802         return;
 803
 804       Display display = text.getDisplay();
 805       fColor = createColor(getPreferenceStore(), PHPEditor.LINK_COLOR, display);
 806     }
 807
 808     /**
 809      * Creates a color from the information stored in the given preference store. Returns <code>null</code> if there is no such
 810      * information available.
 811      */
 812     private Color createColor(IPreferenceStore store, String key, Display display) {
 813
 814       RGB rgb = null;
 815
 816       if (store.contains(key)) {
 817
 818         if (store.isDefault(key))
 819           rgb = PreferenceConverter.getDefaultColor(store, key);
 820         else
 821           rgb = PreferenceConverter.getColor(store, key);
 822
 823         if (rgb != null)
 824           return new Color(display, rgb);
 825       }
 826
 827       return null;
 828     }
 829
 830     private void repairRepresentation() {
 831       repairRepresentation(false);
 832     }
 833
 834     private void repairRepresentation(boolean redrawAll) {
 835
 836       if (fActiveRegion == null)
 837         return;
 838
 839       ISourceViewer viewer = getSourceViewer();
 840       if (viewer != null) {
 841         resetCursor(viewer);
 842
 843         int offset = fActiveRegion.getOffset();
 844         int length = fActiveRegion.getLength();
 845
 846         // remove style
 847         if (!redrawAll && viewer instanceof ITextViewerExtension2)
 848           ((ITextViewerExtension2) viewer).invalidateTextPresentation(offset, length);
 849         else
 850           viewer.invalidateTextPresentation();
 851
 852         // remove underline
 853         if (viewer instanceof ITextViewerExtension3) {
 854           ITextViewerExtension3 extension = (ITextViewerExtension3) viewer;
 855           offset = extension.modelOffset2WidgetOffset(offset);
 856         } else {
 857           offset -= viewer.getVisibleRegion().getOffset();
 858         }
 859
 860         StyledText text = viewer.getTextWidget();
 861         try {
 862           text.redrawRange(offset, length, true);
 863         } catch (IllegalArgumentException x) {
 864           PHPeclipsePlugin.log(x);
 865         }
 866       }
 867
 868       fActiveRegion = null;
 869     }
 870
 871     // will eventually be replaced by a method provided by jdt.core
 872     private IRegion selectWord(IDocument document, int anchor) {
 873
 874       try {
 875         int offset = anchor;
 876         char c;
 877
 878         while (offset >= 0) {
 879           c = document.getChar(offset);
 880           if (!Character.isJavaIdentifierPart(c))
 881             break;
 882           --offset;
 883         }
 884
 885         int start = offset;
 886
 887         offset = anchor;
 888         int length = document.getLength();
 889
 890         while (offset < length) {
 891           c = document.getChar(offset);
 892           if (!Character.isJavaIdentifierPart(c))
 893             break;
 894           ++offset;
 895         }
 896
 897         int end = offset;
 898
 899         if (start == end)
 900           return new Region(start, 0);
 901         else
 902           return new Region(start + 1, end - start - 1);
 903
 904       } catch (BadLocationException x) {
 905         return null;
 906       }
 907     }
 908
 909     IRegion getCurrentTextRegion(ISourceViewer viewer) {
 910
 911       int offset = getCurrentTextOffset(viewer);
 912       if (offset == -1)
 913         return null;
 914
 915       return null;
 916       //                                IJavaElement input= SelectionConverter.getInput(PHPEditor.this);
 917       //                                if (input == null)
 918       //                                        return null;
 919       //
 920       //                                try {
 921       //
 922       //                                        IJavaElement[] elements= null;
 923       //                                        synchronized (input) {
 924       //                                                elements= ((ICodeAssist) input).codeSelect(offset, 0);
 925       //                                        }
 926       //
 927       //                                        if (elements == null || elements.length == 0)
 928       //                                                return null;
 929       //
 930       //                                        return selectWord(viewer.getDocument(), offset);
 931       //
 932       //                                } catch (JavaModelException e) {
 933       //                                        return null;
 934       //                                }
 935     }
 936
 937     private int getCurrentTextOffset(ISourceViewer viewer) {
 938
 939       try {
 940         StyledText text = viewer.getTextWidget();
 941         if (text == null || text.isDisposed())
 942           return -1;
 943
 944         Display display = text.getDisplay();
 945         Point absolutePosition = display.getCursorLocation();
 946         Point relativePosition = text.toControl(absolutePosition);
 947
 948         int widgetOffset = text.getOffsetAtLocation(relativePosition);
 949         if (viewer instanceof ITextViewerExtension3) {
 950           ITextViewerExtension3 extension = (ITextViewerExtension3) viewer;
 951           return extension.widgetOffset2ModelOffset(widgetOffset);
 952         } else {
 953           return widgetOffset + viewer.getVisibleRegion().getOffset();
 954         }
 955
 956       } catch (IllegalArgumentException e) {
 957         return -1;
 958       }
 959     }
 960
 961     private void highlightRegion(ISourceViewer viewer, IRegion region) {
 962
 963       if (region.equals(fActiveRegion))
 964         return;
 965
 966       repairRepresentation();
 967
 968       StyledText text = viewer.getTextWidget();
 969       if (text == null || text.isDisposed())
 970         return;
 971
 972       // highlight region
 973       int offset = 0;
 974       int length = 0;
 975
 976       if (viewer instanceof ITextViewerExtension3) {
 977         ITextViewerExtension3 extension = (ITextViewerExtension3) viewer;
 978         IRegion widgetRange = extension.modelRange2WidgetRange(region);
 979         if (widgetRange == null)
 980           return;
 981
 982         offset = widgetRange.getOffset();
 983         length = widgetRange.getLength();
 984
 985       } else {
 986         offset = region.getOffset() - viewer.getVisibleRegion().getOffset();
 987         length = region.getLength();
 988       }
 989
 990       StyleRange oldStyleRange = text.getStyleRangeAtOffset(offset);
 991       Color foregroundColor = fColor;
 992       Color backgroundColor = oldStyleRange == null ? text.getBackground() : oldStyleRange.background;
 993       StyleRange styleRange = new StyleRange(offset, length, foregroundColor, backgroundColor);
 994       text.setStyleRange(styleRange);
 995
 996       // underline
 997       text.redrawRange(offset, length, true);
 998
 999       fActiveRegion = region;
1000     }
1001
1002     private void activateCursor(ISourceViewer viewer) {
1003       StyledText text = viewer.getTextWidget();
1004       if (text == null || text.isDisposed())
1005         return;
1006       Display display = text.getDisplay();
1007       if (fCursor == null)
1008         fCursor = new Cursor(display, SWT.CURSOR_HAND);
1009       text.setCursor(fCursor);
1010     }
1011
1012     private void resetCursor(ISourceViewer viewer) {
1013       StyledText text = viewer.getTextWidget();
1014       if (text != null && !text.isDisposed())
1015         text.setCursor(null);
1016
1017       if (fCursor != null) {
1018         fCursor.dispose();
1019         fCursor = null;
1020       }
1021     }
1022
1023     /*
1024      * @see org.eclipse.swt.events.KeyListener#keyPressed(org.eclipse.swt.events.KeyEvent)
1025      */
1026     public void keyPressed(KeyEvent event) {
1027
1028       if (fActive) {
1029         deactivate();
1030         return;
1031       }
1032
1033       if (event.keyCode != fKeyModifierMask) {
1034         deactivate();
1035         return;
1036       }
1037
1038       fActive = true;
1039
1040       //                                removed for #25871
1041       //
1042       //                                ISourceViewer viewer= getSourceViewer();
1043       //                                if (viewer == null)
1044       //                                        return;
1045       //
1046       //                                IRegion region= getCurrentTextRegion(viewer);
1047       //                                if (region == null)
1048       //                                        return;
1049       //
1050       //                                highlightRegion(viewer, region);
1051       //                                activateCursor(viewer);
1052     }
1053
1054     /*
1055      * @see org.eclipse.swt.events.KeyListener#keyReleased(org.eclipse.swt.events.KeyEvent)
1056      */
1057     public void keyReleased(KeyEvent event) {
1058
1059       if (!fActive)
1060         return;
1061
1062       deactivate();
1063     }
1064
1065     /*
1066      * @see org.eclipse.swt.events.MouseListener#mouseDoubleClick(org.eclipse.swt.events.MouseEvent)
1067      */
1068     public void mouseDoubleClick(MouseEvent e) {
1069     }
1070
1071     /*
1072      * @see org.eclipse.swt.events.MouseListener#mouseDown(org.eclipse.swt.events.MouseEvent)
1073      */
1074     public void mouseDown(MouseEvent event) {
1075
1076       if (!fActive)
1077         return;
1078
1079       if (event.stateMask != fKeyModifierMask) {
1080         deactivate();
1081         return;
1082       }
1083
1084       if (event.button != 1) {
1085         deactivate();
1086         return;
1087       }
1088     }
1089
1090     /*
1091      * @see org.eclipse.swt.events.MouseListener#mouseUp(org.eclipse.swt.events.MouseEvent)
1092      */
1093     public void mouseUp(MouseEvent e) {
1094
1095       if (!fActive)
1096         return;
1097
1098       if (e.button != 1) {
1099         deactivate();
1100         return;
1101       }
1102
1103       boolean wasActive = fCursor != null;
1104
1105       deactivate();
1106
1107       if (wasActive) {
1108         IAction action = getAction("OpenEditor"); //$NON-NLS-1$
1109         if (action != null)
1110           action.run();
1111       }
1112     }
1113
1114     /*
1115      * @see org.eclipse.swt.events.MouseMoveListener#mouseMove(org.eclipse.swt.events.MouseEvent)
1116      */
1117     public void mouseMove(MouseEvent event) {
1118
1119       if (event.widget instanceof Control && !((Control) event.widget).isFocusControl()) {
1120         deactivate();
1121         return;
1122       }
1123
1124       if (!fActive) {
1125         if (event.stateMask != fKeyModifierMask)
1126           return;
1127         // modifier was already pressed
1128         fActive = true;
1129       }
1130
1131       ISourceViewer viewer = getSourceViewer();
1132       if (viewer == null) {
1133         deactivate();
1134         return;
1135       }
1136
1137       StyledText text = viewer.getTextWidget();
1138       if (text == null || text.isDisposed()) {
1139         deactivate();
1140         return;
1141       }
1142
1143       if ((event.stateMask & SWT.BUTTON1) != 0 && text.getSelectionCount() != 0) {
1144         deactivate();
1145         return;
1146       }
1147
1148       IRegion region = getCurrentTextRegion(viewer);
1149       if (region == null || region.getLength() == 0) {
1150         repairRepresentation();
1151         return;
1152       }
1153
1154       highlightRegion(viewer, region);
1155       activateCursor(viewer);
1156     }
1157
1158     /*
1159      * @see org.eclipse.swt.events.FocusListener#focusGained(org.eclipse.swt.events.FocusEvent)
1160      */
1161     public void focusGained(FocusEvent e) {
1162     }
1163
1164     /*
1165      * @see org.eclipse.swt.events.FocusListener#focusLost(org.eclipse.swt.events.FocusEvent)
1166      */
1167     public void focusLost(FocusEvent event) {
1168       deactivate();
1169     }
1170
1171     /*
1172      * @see org.eclipse.jface.text.IDocumentListener#documentAboutToBeChanged(org.eclipse.jface.text.DocumentEvent)
1173      */
1174     public void documentAboutToBeChanged(DocumentEvent event) {
1175       if (fActive && fActiveRegion != null) {
1176         fRememberedPosition = new Position(fActiveRegion.getOffset(), fActiveRegion.getLength());
1177         try {
1178           event.getDocument().addPosition(fRememberedPosition);
1179         } catch (BadLocationException x) {
1180           fRememberedPosition = null;
1181         }
1182       }
1183     }
1184
1185     /*
1186      * @see org.eclipse.jface.text.IDocumentListener#documentChanged(org.eclipse.jface.text.DocumentEvent)
1187      */
1188     public void documentChanged(DocumentEvent event) {
1189       if (fRememberedPosition != null && !fRememberedPosition.isDeleted()) {
1190         event.getDocument().removePosition(fRememberedPosition);
1191         fActiveRegion = new Region(fRememberedPosition.getOffset(), fRememberedPosition.getLength());
1192       }
1193       fRememberedPosition = null;
1194
1195       ISourceViewer viewer = getSourceViewer();
1196       if (viewer != null) {
1197         StyledText widget = viewer.getTextWidget();
1198         if (widget != null && !widget.isDisposed()) {
1199           widget.getDisplay().asyncExec(new Runnable() {
1200             public void run() {
1201               deactivate();
1202             }
1203           });
1204         }
1205       }
1206     }
1207
1208     /*
1209      * @see org.eclipse.jface.text.ITextInputListener#inputDocumentAboutToBeChanged(org.eclipse.jface.text.IDocument,
1210      *      org.eclipse.jface.text.IDocument)
1211      */
1212     public void inputDocumentAboutToBeChanged(IDocument oldInput, IDocument newInput) {
1213       if (oldInput == null)
1214         return;
1215       deactivate();
1216       oldInput.removeDocumentListener(this);
1217     }
1218
1219     /*
1220      * @see org.eclipse.jface.text.ITextInputListener#inputDocumentChanged(org.eclipse.jface.text.IDocument,
1221      *      org.eclipse.jface.text.IDocument)
1222      */
1223     public void inputDocumentChanged(IDocument oldInput, IDocument newInput) {
1224       if (newInput == null)
1225         return;
1226       newInput.addDocumentListener(this);
1227     }
1228
1229     /*
1230      * @see PaintListener#paintControl(PaintEvent)
1231      */
1232     public void paintControl(PaintEvent event) {
1233       if (fActiveRegion == null)
1234         return;
1235
1236       ISourceViewer viewer = getSourceViewer();
1237       if (viewer == null)
1238         return;
1239
1240       StyledText text = viewer.getTextWidget();
1241       if (text == null || text.isDisposed())
1242         return;
1243
1244       int offset = 0;
1245       int length = 0;
1246
1247       if (viewer instanceof ITextViewerExtension3) {
1248
1249         ITextViewerExtension3 extension = (ITextViewerExtension3) viewer;
1250         IRegion widgetRange = extension.modelRange2WidgetRange(new Region(offset, length));
1251         if (widgetRange == null)
1252           return;
1253
1254         offset = widgetRange.getOffset();
1255         length = widgetRange.getLength();
1256
1257       } else {
1258
1259         IRegion region = viewer.getVisibleRegion();
1260         if (!includes(region, fActiveRegion))
1261           return;
1262
1263         offset = fActiveRegion.getOffset() - region.getOffset();
1264         length = fActiveRegion.getLength();
1265       }
1266
1267       // support for bidi
1268       Point minLocation = getMinimumLocation(text, offset, length);
1269       Point maxLocation = getMaximumLocation(text, offset, length);
1270
1271       int x1 = minLocation.x;
1272       int x2 = minLocation.x + maxLocation.x - minLocation.x - 1;
1273       int y = minLocation.y + text.getLineHeight() - 1;
1274
1275       GC gc = event.gc;
1276       if (fColor != null && !fColor.isDisposed())
1277         gc.setForeground(fColor);
1278       gc.drawLine(x1, y, x2, y);
1279     }
1280
1281     private boolean includes(IRegion region, IRegion position) {
1282       return position.getOffset() >= region.getOffset()
1283           && position.getOffset() + position.getLength() <= region.getOffset() + region.getLength();
1284     }
1285
1286     private Point getMinimumLocation(StyledText text, int offset, int length) {
1287       Point minLocation = new Point(Integer.MAX_VALUE, Integer.MAX_VALUE);
1288
1289       for (int i = 0; i <= length; i++) {
1290         Point location = text.getLocationAtOffset(offset + i);
1291
1292         if (location.x < minLocation.x)
1293           minLocation.x = location.x;
1294         if (location.y < minLocation.y)
1295           minLocation.y = location.y;
1296       }
1297
1298       return minLocation;
1299     }
1300
1301     private Point getMaximumLocation(StyledText text, int offset, int length) {
1302       Point maxLocation = new Point(Integer.MIN_VALUE, Integer.MIN_VALUE);
1303
1304       for (int i = 0; i <= length; i++) {
1305         Point location = text.getLocationAtOffset(offset + i);
1306
1307         if (location.x > maxLocation.x)
1308           maxLocation.x = location.x;
1309         if (location.y > maxLocation.y)
1310           maxLocation.y = location.y;
1311       }
1312
1313       return maxLocation;
1314     }
1315   };
1316
1317   /**
1318    * This action dispatches into two behaviours: If there is no current text hover, the javadoc is displayed using information
1319    * presenter. If there is a current text hover, it is converted into a information presenter in order to make it sticky.
1320    */
1321   class InformationDispatchAction extends TextEditorAction {
1322
1323     /** The wrapped text operation action. */
1324     private final TextOperationAction fTextOperationAction;
1325
1326     /**
1327      * Creates a dispatch action.
1328      */
1329     public InformationDispatchAction(ResourceBundle resourceBundle, String prefix, final TextOperationAction textOperationAction) {
1330       super(resourceBundle, prefix, PHPEditor.this);
1331       if (textOperationAction == null)
1332         throw new IllegalArgumentException();
1333       fTextOperationAction = textOperationAction;
1334     }
1335
1336     /*
1337      * @see org.eclipse.jface.action.IAction#run()
1338      */
1339     public void run() {
1340
1341       ISourceViewer sourceViewer = getSourceViewer();
1342       if (sourceViewer == null) {
1343         fTextOperationAction.run();
1344         return;
1345       }
1346
1347       if (!(sourceViewer instanceof ITextViewerExtension2)) {
1348         fTextOperationAction.run();
1349         return;
1350       }
1351
1352       ITextViewerExtension2 textViewerExtension2 = (ITextViewerExtension2) sourceViewer;
1353
1354       // does a text hover exist?
1355       ITextHover textHover = textViewerExtension2.getCurrentTextHover();
1356       if (textHover == null) {
1357         fTextOperationAction.run();
1358         return;
1359       }
1360
1361       Point hoverEventLocation = textViewerExtension2.getHoverEventLocation();
1362       int offset = computeOffsetAtLocation(sourceViewer, hoverEventLocation.x, hoverEventLocation.y);
1363       if (offset == -1) {
1364         fTextOperationAction.run();
1365         return;
1366       }
1367
1368       try {
1369         // get the text hover content
1370         IDocument document = sourceViewer.getDocument();
1371         String contentType = document.getContentType(offset);
1372
1373         final IRegion hoverRegion = textHover.getHoverRegion(sourceViewer, offset);
1374         if (hoverRegion == null)
1375           return;
1376
1377         final String hoverInfo = textHover.getHoverInfo(sourceViewer, hoverRegion);
1378
1379         // with information provider
1380         IInformationProvider informationProvider = new IInformationProvider() {
1381           /*
1382            * @see org.eclipse.jface.text.information.IInformationProvider#getSubject(org.eclipse.jface.text.ITextViewer, int)
1383            */
1384           public IRegion getSubject(ITextViewer textViewer, int offset) {
1385             return hoverRegion;
1386           }
1387
1388           /*
1389            * @see org.eclipse.jface.text.information.IInformationProvider#getInformation(org.eclipse.jface.text.ITextViewer,
1390            *      org.eclipse.jface.text.IRegion)
1391            */
1392           public String getInformation(ITextViewer textViewer, IRegion subject) {
1393             return hoverInfo;
1394           }
1395         };
1396
1397         fInformationPresenter.setOffset(offset);
1398         fInformationPresenter.setInformationProvider(informationProvider, contentType);
1399         fInformationPresenter.showInformation();
1400
1401       } catch (BadLocationException e) {
1402       }
1403     }
1404
1405     // modified version from TextViewer
1406     private int computeOffsetAtLocation(ITextViewer textViewer, int x, int y) {
1407
1408       StyledText styledText = textViewer.getTextWidget();
1409       IDocument document = textViewer.getDocument();
1410
1411       if (document == null)
1412         return -1;
1413
1414       try {
1415         int widgetLocation = styledText.getOffsetAtLocation(new Point(x, y));
1416         if (textViewer instanceof ITextViewerExtension3) {
1417           ITextViewerExtension3 extension = (ITextViewerExtension3) textViewer;
1418           return extension.widgetOffset2ModelOffset(widgetLocation);
1419         } else {
1420           IRegion visibleRegion = textViewer.getVisibleRegion();
1421           return widgetLocation + visibleRegion.getOffset();
1422         }
1423       } catch (IllegalArgumentException e) {
1424         return -1;
1425       }
1426
1427     }
1428   };
1429
1430   //  static protected class AnnotationAccess implements IAnnotationAccess {
1431   //    /*
1432   //     * @see
1433   // org.eclipse.jface.text.source.IAnnotationAccess#getType(org.eclipse.jface.text.source.Annotation)
1434   //     */
1435   //    public Object getType(Annotation annotation) {
1436   //      if (annotation instanceof IJavaAnnotation) {
1437   //        IJavaAnnotation javaAnnotation = (IJavaAnnotation) annotation;
1438   //   // if (javaAnnotation.isRelevant())
1439   //   // return javaAnnotation.getAnnotationType();
1440   //      }
1441   //      return null;
1442   //    }
1443   //
1444   //    /*
1445   //     * @see
1446   // org.eclipse.jface.text.source.IAnnotationAccess#isMultiLine(org.eclipse.jface.text.source.Annotation)
1447   //     */
1448   //    public boolean isMultiLine(Annotation annotation) {
1449   //      return true;
1450   //    }
1451   //
1452   //    /*
1453   //     * @see
1454   // org.eclipse.jface.text.source.IAnnotationAccess#isTemporary(org.eclipse.jface.text.source.Annotation)
1455   //     */
1456   //    public boolean isTemporary(Annotation annotation) {
1457   //      if (annotation instanceof IJavaAnnotation) {
1458   //        IJavaAnnotation javaAnnotation = (IJavaAnnotation) annotation;
1459   //        if (javaAnnotation.isRelevant())
1460   //          return javaAnnotation.isTemporary();
1461   //      }
1462   //      return false;
1463   //    }
1464   //  };
1465
1466   private class PropertyChangeListener implements org.eclipse.core.runtime.Preferences.IPropertyChangeListener {
1467     /*
1468      * @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)
1469      */
1470     public void propertyChange(org.eclipse.core.runtime.Preferences.PropertyChangeEvent event) {
1471       handlePreferencePropertyChanged(event);
1472     }
1473   };
1474
1475   /**
1476    * Finds and marks occurrence annotations.
1477    *
1478    * @since 3.0
1479    */
1480   class OccurrencesFinderJob extends Job implements IDocumentListener {
1481
1482     private IDocument fDocument;
1483
1484     private boolean fCancelled = false;
1485
1486     private IProgressMonitor fProgressMonitor;
1487
1488     private Position[] fPositions;
1489
1490     public OccurrencesFinderJob(IDocument document, Position[] positions) {
1491       super("Occurrences Marker"); //$NON-NLS-1$
1492       fDocument = document;
1493       fPositions = positions;
1494       fDocument.addDocumentListener(this);
1495     }
1496
1497     private boolean isCancelled() {
1498       return fCancelled || fProgressMonitor.isCanceled();
1499     }
1500
1501     /*
1502      * @see Job#run(org.eclipse.core.runtime.IProgressMonitor)
1503      */
1504     public IStatus run(IProgressMonitor progressMonitor) {
1505
1506       fProgressMonitor = progressMonitor;
1507
1508       try {
1509
1510         if (isCancelled())
1511           return Status.CANCEL_STATUS;
1512
1513         ITextViewer textViewer = getViewer();
1514         if (textViewer == null)
1515           return Status.CANCEL_STATUS;
1516
1517         IDocument document = textViewer.getDocument();
1518         if (document == null)
1519           return Status.CANCEL_STATUS;
1520
1521         IDocumentProvider documentProvider = getDocumentProvider();
1522         if (documentProvider == null)
1523           return Status.CANCEL_STATUS;
1524
1525         IAnnotationModel annotationModel = documentProvider.getAnnotationModel(getEditorInput());
1526         if (annotationModel == null)
1527           return Status.CANCEL_STATUS;
1528
1529         // Add occurrence annotations
1530         int length = fPositions.length;
1531         Map annotationMap = new HashMap(length);
1532         for (int i = 0; i < length; i++) {
1533
1534           if (isCancelled())
1535             return Status.CANCEL_STATUS;
1536
1537           String message;
1538           Position position = fPositions[i];
1539
1540           // Create & add annotation
1541           try {
1542             message = document.get(position.offset, position.length);
1543           } catch (BadLocationException ex) {
1544             // Skip this match
1545             continue;
1546           }
1547           annotationMap.put(new Annotation("net.sourceforge.phpdt.ui.occurrences", false, message), //$NON-NLS-1$
1548               position);
1549         }
1550
1551         if (isCancelled())
1552           return Status.CANCEL_STATUS;
1553
1554         synchronized (annotationModel) {
1555           if (annotationModel instanceof IAnnotationModelExtension) {
1556             ((IAnnotationModelExtension) annotationModel).replaceAnnotations(fOccurrenceAnnotations, annotationMap);
1557           } else {
1558             removeOccurrenceAnnotations();
1559             Iterator iter = annotationMap.entrySet().iterator();
1560             while (iter.hasNext()) {
1561               Map.Entry mapEntry = (Map.Entry) iter.next();
1562               annotationModel.addAnnotation((Annotation) mapEntry.getKey(), (Position) mapEntry.getValue());
1563             }
1564           }
1565           fOccurrenceAnnotations = (Annotation[]) annotationMap.keySet().toArray(new Annotation[annotationMap.keySet().size()]);
1566         }
1567       } finally {
1568         fDocument.removeDocumentListener(this);
1569       }
1570       return Status.OK_STATUS;
1571     }
1572
1573     /*
1574      * @see org.eclipse.jface.text.IDocumentListener#documentAboutToBeChanged(org.eclipse.jface.text.DocumentEvent)
1575      */
1576     public void documentAboutToBeChanged(DocumentEvent event) {
1577       fCancelled = true;
1578     }
1579
1580     /*
1581      * @see org.eclipse.jface.text.IDocumentListener#documentChanged(org.eclipse.jface.text.DocumentEvent)
1582      */
1583     public void documentChanged(DocumentEvent event) {
1584     }
1585   }
1586
1587   /**
1588    * Updates the selection in the editor's widget with the selection of the outline page.
1589    */
1590   class OutlineSelectionChangedListener extends AbstractSelectionChangedListener {
1591     public void selectionChanged(SelectionChangedEvent event) {
1592       doSelectionChanged(event);
1593     }
1594   }
1595
1596   /**
1597    * Holds the current occurrence annotations.
1598    *
1599    * @since 3.0
1600    */
1601   private Annotation[] fOccurrenceAnnotations = null;
1602
1603   private Job fOccurrencesFinderJob;
1604
1605   /** Preference key for showing the line number ruler */
1606   //  private final static String LINE_NUMBER_RULER =
1607   // PreferenceConstants.EDITOR_LINE_NUMBER_RULER;
1608   /** Preference key for the foreground color of the line numbers */
1609   // private final static String LINE_NUMBER_COLOR =
1610   // PreferenceConstants.EDITOR_LINE_NUMBER_RULER_COLOR;
1611   /** Preference key for the link color */
1612   private final static String LINK_COLOR = PreferenceConstants.EDITOR_LINK_COLOR;
1613
1614   /** Preference key for compiler task tags */
1615   private final static String COMPILER_TASK_TAGS = JavaCore.COMPILER_TASK_TAGS;
1616
1617   // protected PHPActionGroup fActionGroups;
1618   //  /** The outline page */
1619   //  private AbstractContentOutlinePage fOutlinePage;
1620   /** The outline page */
1621   protected JavaOutlinePage fOutlinePage;
1622
1623   /** Outliner context menu Id */
1624   protected String fOutlinerContextMenuId;
1625
1626   /**
1627    * The editor selection changed listener.
1628    *
1629    * @since 3.0
1630    */
1631   //  private EditorSelectionChangedListener fEditorSelectionChangedListener;
1632   /**
1633    * Indicates whether this editor should react on outline page selection changes
1634    */
1635   private int fIgnoreOutlinePageSelection;
1636
1637   /** The outline page selection updater */
1638   private OutlinePageSelectionUpdater fUpdater;
1639
1640   //  protected PHPSyntaxParserThread fValidationThread = null;
1641
1642   // private IPreferenceStore fPHPPrefStore;
1643   /** The selection changed listener */
1644   //  protected ISelectionChangedListener fSelectionChangedListener = new
1645   // SelectionChangedListener();
1646   /**
1647    * The editor selection changed listener.
1648    *
1649    * @since 3.0
1650    */
1651   private EditorSelectionChangedListener fEditorSelectionChangedListener;
1652
1653   /** The selection changed listener */
1654   protected AbstractSelectionChangedListener fOutlineSelectionChangedListener = new OutlineSelectionChangedListener();
1655
1656   /** The editor's bracket matcher */
1657   private PHPPairMatcher fBracketMatcher = new PHPPairMatcher(BRACKETS);
1658
1659   /** The line number ruler column */
1660   //  private LineNumberRulerColumn fLineNumberRulerColumn;
1661   /** This editor's encoding support */
1662   private DefaultEncodingSupport fEncodingSupport;
1663
1664   /** The mouse listener */
1665   private MouseClickListener fMouseListener;
1666
1667   protected CompositeActionGroup fActionGroups;
1668
1669   protected CompositeActionGroup fContextMenuGroup;
1670
1671   /**
1672    * This editor's projection support
1673    *
1674    * @since 3.0
1675    */
1676   private ProjectionSupport fProjectionSupport;
1677
1678   /**
1679    * This editor's projection model updater
1680    *
1681    * @since 3.0
1682    */
1683   private IJavaFoldingStructureProvider fProjectionModelUpdater;
1684
1685   /**
1686    * The action group for folding.
1687    *
1688    * @since 3.0
1689    */
1690   private FoldingActionGroup fFoldingGroup;
1691
1692   /** The information presenter. */
1693   private InformationPresenter fInformationPresenter;
1694
1695   /** The annotation access */
1696   //  protected IAnnotationAccess fAnnotationAccess = new AnnotationAccess();
1697   /** The overview ruler */
1698   protected OverviewRuler isOverviewRulerVisible;
1699
1700   /** The source viewer decoration support */
1701   //protected SourceViewerDecorationSupport fSourceViewerDecorationSupport;
1702   /** The overview ruler */
1703   //protected OverviewRuler fOverviewRuler;
1704   /** The preference property change listener for java core. */
1705   private org.eclipse.core.runtime.Preferences.IPropertyChangeListener fPropertyChangeListener = new PropertyChangeListener();
1706
1707   /**
1708    * Returns the most narrow java element including the given offset
1709    *
1710    * @param offset
1711    *          the offset inside of the requested element
1712    */
1713   abstract protected IJavaElement getElementAt(int offset);
1714
1715   /**
1716    * Returns the java element of this editor's input corresponding to the given IJavaElement
1717    */
1718   abstract protected IJavaElement getCorrespondingElement(IJavaElement element);
1719
1720   /**
1721    * Sets the input of the editor's outline page.
1722    */
1723   abstract protected void setOutlinePageInput(JavaOutlinePage page, IEditorInput input);
1724
1725   /**
1726    * Default constructor.
1727    */
1728   public PHPEditor() {
1729     super();
1730   }
1731
1732   /*
1733    * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#initializeKeyBindingScopes()
1734    */
1735   protected void initializeKeyBindingScopes() {
1736     setKeyBindingScopes(new String[] { "net.sourceforge.phpdt.ui.phpEditorScope" }); //$NON-NLS-1$
1737   }
1738
1739   /*
1740    * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#initializeEditor()
1741    */
1742   protected void initializeEditor() {
1743     //jsurfer old code
1744     JavaTextTools textTools = PHPeclipsePlugin.getDefault().getJavaTextTools();
1745     setSourceViewerConfiguration(new PHPSourceViewerConfiguration(textTools, this, IPHPPartitions.PHP_PARTITIONING)); //, IJavaPartitions.JAVA_PARTITIONING));
1746     setRangeIndicator(new DefaultRangeIndicator());
1747     //          IPreferenceStore store=
1748     // PHPeclipsePlugin.getDefault().getPreferenceStore();
1749     //          setPreferenceStore(store);
1750     IPreferenceStore store = createCombinedPreferenceStore(null);
1751     setPreferenceStore(store);
1752
1753     // TODO changed in 3.x ?
1754     if (PreferenceConstants.getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SYNC_OUTLINE_ON_CURSOR_MOVE))
1755       fUpdater = new OutlinePageSelectionUpdater();
1756     // jsurfer end
1757
1758     //          IPreferenceStore store= createCombinedPreferenceStore(null);
1759     //          setPreferenceStore(store);
1760     //          JavaTextTools textTools=
1761     // PHPeclipsePlugin.getDefault().getJavaTextTools();
1762     //          setSourceViewerConfiguration(new
1763     // JavaSourceViewerConfiguration(textTools.getColorManager(), store,
1764     // this, IJavaPartitions.JAVA_PARTITIONING));
1765     //          fMarkOccurrenceAnnotations=
1766     // store.getBoolean(PreferenceConstants.EDITOR_MARK_OCCURRENCES);
1767     //          fStickyOccurrenceAnnotations=
1768     // store.getBoolean(PreferenceConstants.EDITOR_STICKY_OCCURRENCES);
1769     //          fMarkTypeOccurrences=
1770     // store.getBoolean(PreferenceConstants.EDITOR_MARK_TYPE_OCCURRENCES);
1771     //          fMarkMethodOccurrences=
1772     // store.getBoolean(PreferenceConstants.EDITOR_MARK_METHOD_OCCURRENCES);
1773     //          fMarkConstantOccurrences=
1774     // store.getBoolean(PreferenceConstants.EDITOR_MARK_CONSTANT_OCCURRENCES);
1775     //          fMarkFieldOccurrences=
1776     // store.getBoolean(PreferenceConstants.EDITOR_MARK_FIELD_OCCURRENCES);
1777     //          fMarkLocalVariableypeOccurrences=
1778     // store.getBoolean(PreferenceConstants.EDITOR_MARK_LOCAL_VARIABLE_OCCURRENCES);
1779     //          fMarkExceptionOccurrences=
1780     // store.getBoolean(PreferenceConstants.EDITOR_MARK_EXCEPTION_OCCURRENCES);
1781     //          fMarkMethodExitPoints=
1782     // store.getBoolean(PreferenceConstants.EDITOR_MARK_METHOD_EXIT_POINTS);
1783   }
1784
1785   /*
1786    * @see org.eclipse.ui.texteditor.AbstractTextEditor#updatePropertyDependentActions()
1787    */
1788   protected void updatePropertyDependentActions() {
1789     super.updatePropertyDependentActions();
1790     if (fEncodingSupport != null)
1791       fEncodingSupport.reset();
1792   }
1793
1794   /*
1795    * Update the hovering behavior depending on the preferences.
1796    */
1797   private void updateHoverBehavior() {
1798     SourceViewerConfiguration configuration = getSourceViewerConfiguration();
1799     String[] types = configuration.getConfiguredContentTypes(getSourceViewer());
1800
1801     for (int i = 0; i < types.length; i++) {
1802
1803       String t = types[i];
1804
1805       int[] stateMasks = configuration.getConfiguredTextHoverStateMasks(getSourceViewer(), t);
1806
1807       ISourceViewer sourceViewer = getSourceViewer();
1808       if (sourceViewer instanceof ITextViewerExtension2) {
1809         if (stateMasks != null) {
1810           for (int j = 0; j < stateMasks.length; j++) {
1811             int stateMask = stateMasks[j];
1812             ITextHover textHover = configuration.getTextHover(sourceViewer, t, stateMask);
1813             ((ITextViewerExtension2) sourceViewer).setTextHover(textHover, t, stateMask);
1814           }
1815         } else {
1816           ITextHover textHover = configuration.getTextHover(sourceViewer, t);
1817           ((ITextViewerExtension2) sourceViewer).setTextHover(textHover, t, ITextViewerExtension2.DEFAULT_HOVER_STATE_MASK);
1818         }
1819       } else
1820         sourceViewer.setTextHover(configuration.getTextHover(sourceViewer, t), t);
1821     }
1822   }
1823
1824   public void updatedTitleImage(Image image) {
1825     setTitleImage(image);
1826   }
1827
1828   /*
1829    * @see net.sourceforge.phpdt.internal.ui.viewsupport.IViewPartInputProvider#getViewPartInput()
1830    */
1831   public Object getViewPartInput() {
1832     return getEditorInput().getAdapter(IResource.class);
1833   }
1834
1835   /*
1836    * @see org.eclipse.ui.texteditor.AbstractTextEditor#doSetSelection(ISelection)
1837    */
1838   protected void doSetSelection(ISelection selection) {
1839     super.doSetSelection(selection);
1840     synchronizeOutlinePageSelection();
1841   }
1842
1843   boolean isFoldingEnabled() {
1844     return PHPeclipsePlugin.getDefault().getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_FOLDING_ENABLED);
1845   }
1846
1847   /*
1848    * @see org.eclipse.ui.IWorkbenchPart#createPartControl(org.eclipse.swt. widgets.Composite)
1849    */
1850   public void createPartControl(Composite parent) {
1851     super.createPartControl(parent);
1852
1853     //fSourceViewerDecorationSupport.install(getPreferenceStore());
1854
1855     ProjectionViewer projectionViewer = (ProjectionViewer) getSourceViewer();
1856
1857     fProjectionSupport = new ProjectionSupport(projectionViewer, getAnnotationAccess(), getSharedColors());
1858     fProjectionSupport.addSummarizableAnnotationType("org.eclipse.ui.workbench.texteditor.error"); //$NON-NLS-1$
1859     fProjectionSupport.addSummarizableAnnotationType("org.eclipse.ui.workbench.texteditor.warning"); //$NON-NLS-1$
1860     fProjectionSupport.setHoverControlCreator(new IInformationControlCreator() {
1861       public IInformationControl createInformationControl(Shell shell) {
1862         return new CustomSourceInformationControl(shell, IDocument.DEFAULT_CONTENT_TYPE);
1863       }
1864     });
1865     fProjectionSupport.install();
1866
1867     fProjectionModelUpdater = PHPeclipsePlugin.getDefault().getFoldingStructureProviderRegistry().getCurrentFoldingProvider();
1868     if (fProjectionModelUpdater != null)
1869       fProjectionModelUpdater.install(this, projectionViewer);
1870
1871     if (isFoldingEnabled())
1872       projectionViewer.doOperation(ProjectionViewer.TOGGLE);
1873     Preferences preferences = PHPeclipsePlugin.getDefault().getPluginPreferences();
1874     preferences.addPropertyChangeListener(fPropertyChangeListener);
1875
1876     IInformationControlCreator informationControlCreator = new IInformationControlCreator() {
1877       public IInformationControl createInformationControl(Shell parent) {
1878         boolean cutDown = false;
1879         int style = cutDown ? SWT.NONE : (SWT.V_SCROLL | SWT.H_SCROLL);
1880         return new DefaultInformationControl(parent, SWT.RESIZE, style, new HTMLTextPresenter(cutDown));
1881       }
1882     };
1883
1884     fInformationPresenter = new InformationPresenter(informationControlCreator);
1885     fInformationPresenter.setSizeConstraints(60, 10, true, true);
1886     fInformationPresenter.install(getSourceViewer());
1887
1888     fEditorSelectionChangedListener = new EditorSelectionChangedListener();
1889     fEditorSelectionChangedListener.install(getSelectionProvider());
1890
1891     if (PreferenceConstants.getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_DISABLE_OVERWRITE_MODE))
1892       enableOverwriteMode(false);
1893
1894     //  getEditorSite().getShell().addShellListener(fActivationListener);
1895   }
1896
1897   protected void configureSourceViewerDecorationSupport(SourceViewerDecorationSupport support) {
1898
1899         support.setCharacterPairMatcher(fBracketMatcher);
1900         support.setMatchingCharacterPainterPreferenceKeys(MATCHING_BRACKETS, MATCHING_BRACKETS_COLOR);
1901
1902         super.configureSourceViewerDecorationSupport(support);
1903   }
1904
1905   /**
1906    * Returns this document's complete text.
1907    *
1908    * @return the document's complete text
1909    */
1910   public String get() {
1911     IDocument doc = this.getDocumentProvider().getDocument(this.getEditorInput());
1912     return doc.get();
1913   }
1914
1915   /**
1916    * Sets the outliner's context menu ID.
1917    */
1918   protected void setOutlinerContextMenuId(String menuId) {
1919     fOutlinerContextMenuId = menuId;
1920   }
1921
1922   /**
1923    * Returns the standard action group of this editor.
1924    */
1925   protected ActionGroup getActionGroup() {
1926     return fActionGroups;
1927   }
1928
1929   //  public JavaOutlinePage getfOutlinePage() {
1930   //    return fOutlinePage;
1931   //  }
1932
1933   /**
1934    * The <code>PHPEditor</code> implementation of this <code>AbstractTextEditor</code> method extend the actions to add those
1935    * specific to the receiver
1936    */
1937   protected void createActions() {
1938     super.createActions();
1939
1940     fFoldingGroup = new FoldingActionGroup(this, getViewer());
1941
1942     ResourceAction resAction = new TextOperationAction(PHPEditorMessages.getResourceBundle(),
1943         "ShowJavaDoc.", this, ISourceViewer.INFORMATION, true); //$NON-NLS-1$
1944     resAction = new InformationDispatchAction(PHPEditorMessages.getResourceBundle(),
1945         "ShowJavaDoc.", (TextOperationAction) resAction); //$NON-NLS-1$
1946     resAction.setActionDefinitionId(net.sourceforge.phpdt.ui.actions.PHPEditorActionDefinitionIds.SHOW_JAVADOC);
1947     setAction("ShowJavaDoc", resAction); //$NON-NLS-1$
1948     //  WorkbenchHelp.setHelp(resAction,
1949     // IJavaHelpContextIds.SHOW_JAVADOC_ACTION);
1950
1951     Action action = new GotoMatchingBracketAction(this);
1952     action.setActionDefinitionId(PHPEditorActionDefinitionIds.GOTO_MATCHING_BRACKET);
1953     setAction(GotoMatchingBracketAction.GOTO_MATCHING_BRACKET, action);
1954
1955     //  action= new
1956     // TextOperationAction(PHPEditorMessages.getResourceBundle(),"ShowOutline.",
1957     // this, JavaSourceViewer.SHOW_OUTLINE, true); //$NON-NLS-1$
1958     //  action.setActionDefinitionId(PHPEditorActionDefinitionIds.SHOW_OUTLINE);
1959     //  setAction(PHPEditorActionDefinitionIds.SHOW_OUTLINE, action);
1960     //// WorkbenchHelp.setHelp(action,
1961     // IJavaHelpContextIds.SHOW_OUTLINE_ACTION);
1962     //
1963     //  action= new
1964     // TextOperationAction(PHPEditorMessages.getResourceBundle(),"OpenStructure.",
1965     // this, JavaSourceViewer.OPEN_STRUCTURE, true); //$NON-NLS-1$
1966     //  action.setActionDefinitionId(PHPEditorActionDefinitionIds.SHOW_OUTLINE.OPEN_STRUCTURE);
1967     //  setAction(PHPEditorActionDefinitionIds.SHOW_OUTLINE.OPEN_STRUCTURE,
1968     // action);
1969     //// WorkbenchHelp.setHelp(action,
1970     // IJavaHelpContextIds.OPEN_STRUCTURE_ACTION);
1971     //
1972     //  action= new
1973     // TextOperationAction(PHPEditorMessages.getResourceBundle(),"OpenHierarchy.",
1974     // this, JavaSourceViewer.SHOW_HIERARCHY, true); //$NON-NLS-1$
1975     //  action.setActionDefinitionId(PHPEditorActionDefinitionIds.SHOW_OUTLINE.OPEN_HIERARCHY);
1976     //  setAction(PHPEditorActionDefinitionIds.SHOW_OUTLINE.OPEN_HIERARCHY,
1977     // action);
1978     //// WorkbenchHelp.setHelp(action,
1979     // IJavaHelpContextIds.OPEN_HIERARCHY_ACTION);
1980
1981     fEncodingSupport = new DefaultEncodingSupport();
1982     fEncodingSupport.initialize(this);
1983
1984     //  fSelectionHistory= new SelectionHistory(this);
1985     //
1986     //  action= new StructureSelectEnclosingAction(this, fSelectionHistory);
1987     //  action.setActionDefinitionId(PHPEditorActionDefinitionIds.SELECT_ENCLOSING);
1988     //  setAction(StructureSelectionAction.ENCLOSING, action);
1989     //
1990     //  action= new StructureSelectNextAction(this, fSelectionHistory);
1991     //  action.setActionDefinitionId(PHPEditorActionDefinitionIds.SELECT_NEXT);
1992     //  setAction(StructureSelectionAction.NEXT, action);
1993     //
1994     //  action= new StructureSelectPreviousAction(this, fSelectionHistory);
1995     //  action.setActionDefinitionId(PHPEditorActionDefinitionIds.SELECT_PREVIOUS);
1996     //  setAction(StructureSelectionAction.PREVIOUS, action);
1997     //
1998     //  StructureSelectHistoryAction historyAction= new
1999     // StructureSelectHistoryAction(this, fSelectionHistory);
2000     //  historyAction.setActionDefinitionId(PHPEditorActionDefinitionIds.SELECT_LAST);
2001     //  setAction(StructureSelectionAction.HISTORY, historyAction);
2002     //  fSelectionHistory.setHistoryAction(historyAction);
2003     //
2004     //  action= GoToNextPreviousMemberAction.newGoToNextMemberAction(this);
2005     //  action.setActionDefinitionId(PHPEditorActionDefinitionIds.GOTO_NEXT_MEMBER);
2006     //  setAction(GoToNextPreviousMemberAction.NEXT_MEMBER, action);
2007     //
2008     //  action=
2009     // GoToNextPreviousMemberAction.newGoToPreviousMemberAction(this);
2010     //  action.setActionDefinitionId(PHPEditorActionDefinitionIds.GOTO_PREVIOUS_MEMBER);
2011     //  setAction(GoToNextPreviousMemberAction.PREVIOUS_MEMBER, action);
2012     //
2013     //  action= new QuickFormatAction();
2014     //  action.setActionDefinitionId(PHPEditorActionDefinitionIds.QUICK_FORMAT);
2015     //  setAction(IJavaEditorActionDefinitionIds.QUICK_FORMAT, action);
2016     //
2017     //  action= new RemoveOccurrenceAnnotations(this);
2018     //  action.setActionDefinitionId(PHPEditorActionDefinitionIds.REMOVE_OCCURRENCE_ANNOTATIONS);
2019     //  setAction("RemoveOccurrenceAnnotations", action); //$NON-NLS-1$
2020
2021     // add annotation actions
2022     action = new JavaSelectMarkerRulerAction2(PHPEditorMessages.getResourceBundle(), "Editor.RulerAnnotationSelection.", this); //$NON-NLS-1$
2023     setAction("AnnotationAction", action); //$NON-NLS-1$
2024   }
2025
2026   private void internalDoSetInput(IEditorInput input) throws CoreException {
2027     super.doSetInput(input);
2028
2029     if (getSourceViewer() instanceof JavaSourceViewer) {
2030                 JavaSourceViewer viewer= (JavaSourceViewer)getSourceViewer();
2031                 if (viewer.getReconciler() == null) {
2032                         IReconciler reconciler= getSourceViewerConfiguration().getReconciler(viewer);
2033                         if (reconciler != null) {
2034                                 reconciler.install(viewer);
2035                                 viewer.setReconciler(reconciler);
2036                         }
2037                 }
2038         }
2039
2040     if (fEncodingSupport != null)
2041       fEncodingSupport.reset();
2042
2043     setOutlinePageInput(fOutlinePage, input);
2044
2045     if (fProjectionModelUpdater != null)
2046       fProjectionModelUpdater.initialize();
2047
2048 //    if (isShowingOverrideIndicators())
2049 //              installOverrideIndicator(false);
2050   }
2051
2052   /*
2053    * @see org.eclipse.ui.texteditor.AbstractTextEditor#setPreferenceStore(org.eclipse.jface.preference.IPreferenceStore)
2054    * @since 3.0
2055    */
2056   protected void setPreferenceStore(IPreferenceStore store) {
2057     super.setPreferenceStore(store);
2058     if (getSourceViewerConfiguration() instanceof PHPSourceViewerConfiguration) {
2059       JavaTextTools textTools = PHPeclipsePlugin.getDefault().getJavaTextTools();
2060       setSourceViewerConfiguration(new PHPSourceViewerConfiguration(textTools.getColorManager(), store, this,
2061           IPHPPartitions.PHP_PARTITIONING));
2062     }
2063     if (getSourceViewer() instanceof JavaSourceViewer)
2064       ((JavaSourceViewer) getSourceViewer()).setPreferenceStore(store);
2065   }
2066
2067   /**
2068    * The <code>PHPEditor</code> implementation of this <code>AbstractTextEditor</code> method performs any extra disposal
2069    * actions required by the php editor.
2070    */
2071   public void dispose() {
2072     if (fProjectionModelUpdater != null) {
2073       fProjectionModelUpdater.uninstall();
2074       fProjectionModelUpdater = null;
2075     }
2076
2077     if (fProjectionSupport != null) {
2078       fProjectionSupport.dispose();
2079       fProjectionSupport = null;
2080     }
2081     //   PHPEditorEnvironment.disconnect(this);
2082     if (fOutlinePage != null)
2083       fOutlinePage.setInput(null);
2084
2085     if (fActionGroups != null)
2086       fActionGroups.dispose();
2087
2088     if (isBrowserLikeLinks())
2089       disableBrowserLikeLinks();
2090
2091     if (fEncodingSupport != null) {
2092       fEncodingSupport.dispose();
2093       fEncodingSupport = null;
2094     }
2095
2096     if (fPropertyChangeListener != null) {
2097       Preferences preferences = PHPeclipsePlugin.getDefault().getPluginPreferences();
2098       preferences.removePropertyChangeListener(fPropertyChangeListener);
2099       fPropertyChangeListener = null;
2100     }
2101
2102     //    if (fSourceViewerDecorationSupport != null) {
2103     //      fSourceViewerDecorationSupport.dispose();
2104     //      fSourceViewerDecorationSupport = null;
2105     //    }
2106
2107     if (fBracketMatcher != null) {
2108       fBracketMatcher.dispose();
2109       fBracketMatcher = null;
2110     }
2111
2112     if (fEditorSelectionChangedListener != null) {
2113       fEditorSelectionChangedListener.uninstall(getSelectionProvider());
2114       fEditorSelectionChangedListener = null;
2115     }
2116
2117     super.dispose();
2118   }
2119
2120   /**
2121    * The <code>PHPEditor</code> implementation of this <code>AbstractTextEditor</code> method performs any extra revert behavior
2122    * required by the php editor.
2123    */
2124   //  public void doRevertToSaved() {
2125   //    super.doRevertToSaved();
2126   //    if (fOutlinePage != null)
2127   //      fOutlinePage.update();
2128   //  }
2129   /**
2130    * The <code>PHPEditor</code> implementation of this <code>AbstractTextEditor</code> method performs any extra save behavior
2131    * required by the php editor.
2132    */
2133   //  public void doSave(IProgressMonitor monitor) {
2134   //    super.doSave(monitor);
2135   // compile or not, according to the user preferences
2136   // IPreferenceStore store = getPreferenceStore();
2137   // the parse on save was changed to the eclipse "builders" concept
2138   //    if (store.getBoolean(PHPeclipsePlugin.PHP_PARSE_ON_SAVE)) {
2139   //      IAction a = PHPParserAction.getInstance();
2140   //      if (a != null)
2141   //        a.run();
2142   //    }
2143   //    if (SWT.getPlatform().equals("win32")) {
2144   //      IAction a = ShowExternalPreviewAction.getInstance();
2145   //      if (a != null)
2146   //        a.run();
2147   //    }
2148   //    if (fOutlinePage != null)
2149   //      fOutlinePage.update();
2150   //  }
2151   /**
2152    * The <code>PHPEditor</code> implementation of this <code>AbstractTextEditor</code> method performs any extra save as
2153    * behavior required by the php editor.
2154    */
2155   //  public void doSaveAs() {
2156   //    super.doSaveAs();
2157   //    if (fOutlinePage != null)
2158   //      fOutlinePage.update();
2159   //  }
2160   /*
2161    * @see StatusTextEditor#getStatusHeader(IStatus)
2162    */
2163   protected String getStatusHeader(IStatus status) {
2164     if (fEncodingSupport != null) {
2165       String message = fEncodingSupport.getStatusHeader(status);
2166       if (message != null)
2167         return message;
2168     }
2169     return super.getStatusHeader(status);
2170   }
2171
2172   /*
2173    * @see StatusTextEditor#getStatusBanner(IStatus)
2174    */
2175   protected String getStatusBanner(IStatus status) {
2176     if (fEncodingSupport != null) {
2177       String message = fEncodingSupport.getStatusBanner(status);
2178       if (message != null)
2179         return message;
2180     }
2181     return super.getStatusBanner(status);
2182   }
2183
2184   /*
2185    * @see StatusTextEditor#getStatusMessage(IStatus)
2186    */
2187   protected String getStatusMessage(IStatus status) {
2188     if (fEncodingSupport != null) {
2189       String message = fEncodingSupport.getStatusMessage(status);
2190       if (message != null)
2191         return message;
2192     }
2193     return super.getStatusMessage(status);
2194   }
2195
2196   /**
2197    * The <code>PHPEditor</code> implementation of this <code>AbstractTextEditor</code> method performs sets the input of the
2198    * outline page after AbstractTextEditor has set input.
2199    */
2200   //  protected void doSetInput(IEditorInput input) throws CoreException {
2201   //    super.doSetInput(input);
2202   //
2203   //    if (fEncodingSupport != null)
2204   //      fEncodingSupport.reset();
2205   //    if (fOutlinePage != null)
2206   //      fOutlinePage.setInput(input);
2207   //    // setOutlinePageInput(fOutlinePage, input);
2208   //  }
2209   protected void doSetInput(IEditorInput input) throws CoreException {
2210     super.doSetInput(input);
2211     if (fEncodingSupport != null)
2212       fEncodingSupport.reset();
2213     setOutlinePageInput(fOutlinePage, input);
2214   }
2215
2216   /*
2217    * @see org.phpeclipse.phpdt.internal.ui.viewsupport.IViewPartInputProvider#getViewPartInput()
2218    */
2219   //  public Object getViewPartInput() {
2220   //    return getEditorInput().getAdapter(IFile.class);
2221   //  }
2222   /**
2223    * The <code>PHPEditor</code> implementation of this <code>AbstractTextEditor</code> method adds any PHPEditor specific
2224    * entries.
2225    */
2226   public void editorContextMenuAboutToShow(MenuManager menu) {
2227     super.editorContextMenuAboutToShow(menu);
2228     menu.appendToGroup(ITextEditorActionConstants.GROUP_UNDO, new Separator(IContextMenuConstants.GROUP_OPEN));
2229     menu.insertAfter(IContextMenuConstants.GROUP_OPEN, new GroupMarker(IContextMenuConstants.GROUP_SHOW));
2230
2231     ActionContext context = new ActionContext(getSelectionProvider().getSelection());
2232     fContextMenuGroup.setContext(context);
2233     fContextMenuGroup.fillContextMenu(menu);
2234     fContextMenuGroup.setContext(null);
2235     //    addAction(menu, ITextEditorActionConstants.GROUP_EDIT, "Format");
2236     // //$NON-NLS-1$
2237     //
2238     //    ActionContext context =
2239     //      new ActionContext(getSelectionProvider().getSelection());
2240     //    fContextMenuGroup.setContext(context);
2241     //    fContextMenuGroup.fillContextMenu(menu);
2242     //    fContextMenuGroup.setContext(null);
2243   }
2244
2245   /**
2246    * Creates the outline page used with this editor.
2247    */
2248   protected JavaOutlinePage createOutlinePage() {
2249     JavaOutlinePage page = new JavaOutlinePage(fOutlinerContextMenuId, this);
2250     fOutlineSelectionChangedListener.install(page);
2251     setOutlinePageInput(page, getEditorInput());
2252     return page;
2253   }
2254
2255   /**
2256    * Informs the editor that its outliner has been closed.
2257    */
2258   public void outlinePageClosed() {
2259     if (fOutlinePage != null) {
2260       fOutlineSelectionChangedListener.uninstall(fOutlinePage);
2261       fOutlinePage = null;
2262       resetHighlightRange();
2263     }
2264   }
2265
2266   /**
2267    * Synchronizes the outliner selection with the given element position in the editor.
2268    *
2269    * @param element
2270    *          the java element to select
2271    */
2272   protected void synchronizeOutlinePage(ISourceReference element) {
2273     synchronizeOutlinePage(element, true);
2274   }
2275
2276   /**
2277    * Synchronizes the outliner selection with the given element position in the editor.
2278    *
2279    * @param element
2280    *          the java element to select
2281    * @param checkIfOutlinePageActive
2282    *          <code>true</code> if check for active outline page needs to be done
2283    */
2284   protected void synchronizeOutlinePage(ISourceReference element, boolean checkIfOutlinePageActive) {
2285     if (fOutlinePage != null && element != null && !(checkIfOutlinePageActive && isJavaOutlinePageActive())) {
2286       fOutlineSelectionChangedListener.uninstall(fOutlinePage);
2287       fOutlinePage.select(element);
2288       fOutlineSelectionChangedListener.install(fOutlinePage);
2289     }
2290   }
2291
2292   /**
2293    * Synchronizes the outliner selection with the actual cursor position in the editor.
2294    */
2295   public void synchronizeOutlinePageSelection() {
2296     synchronizeOutlinePage(computeHighlightRangeSourceReference());
2297
2298     //    ISourceViewer sourceViewer = getSourceViewer();
2299     //    if (sourceViewer == null || fOutlinePage == null)
2300     //      return;
2301     //
2302     //    StyledText styledText = sourceViewer.getTextWidget();
2303     //    if (styledText == null)
2304     //      return;
2305     //
2306     //    int caret = 0;
2307     //    if (sourceViewer instanceof ITextViewerExtension3) {
2308     //      ITextViewerExtension3 extension = (ITextViewerExtension3)
2309     // sourceViewer;
2310     //      caret =
2311     // extension.widgetOffset2ModelOffset(styledText.getCaretOffset());
2312     //    } else {
2313     //      int offset = sourceViewer.getVisibleRegion().getOffset();
2314     //      caret = offset + styledText.getCaretOffset();
2315     //    }
2316     //
2317     //    IJavaElement element = getElementAt(caret);
2318     //    if (element instanceof ISourceReference) {
2319     //      fOutlinePage.removeSelectionChangedListener(fSelectionChangedListener);
2320     //      fOutlinePage.select((ISourceReference) element);
2321     //      fOutlinePage.addSelectionChangedListener(fSelectionChangedListener);
2322     //    }
2323   }
2324
2325   protected void setSelection(ISourceReference reference, boolean moveCursor) {
2326
2327     ISelection selection = getSelectionProvider().getSelection();
2328     if (selection instanceof TextSelection) {
2329       TextSelection textSelection = (TextSelection) selection;
2330       if (textSelection.getOffset() != 0 || textSelection.getLength() != 0)
2331         markInNavigationHistory();
2332     }
2333
2334     if (reference != null) {
2335
2336       StyledText textWidget = null;
2337
2338       ISourceViewer sourceViewer = getSourceViewer();
2339       if (sourceViewer != null)
2340         textWidget = sourceViewer.getTextWidget();
2341
2342       if (textWidget == null)
2343         return;
2344
2345       try {
2346
2347         ISourceRange range = reference.getSourceRange();
2348         if (range == null)
2349           return;
2350
2351         int offset = range.getOffset();
2352         int length = range.getLength();
2353
2354         if (offset < 0 || length < 0)
2355           return;
2356
2357         textWidget.setRedraw(false);
2358
2359         setHighlightRange(offset, length, moveCursor);
2360
2361         if (!moveCursor)
2362           return;
2363
2364         offset = -1;
2365         length = -1;
2366
2367         if (reference instanceof IMember) {
2368           range = ((IMember) reference).getNameRange();
2369           if (range != null) {
2370             offset = range.getOffset();
2371             length = range.getLength();
2372           }
2373         }
2374         //                                      else if (reference instanceof IImportDeclaration) {
2375         //                                              String name= ((IImportDeclaration)
2376         // reference).getElementName();
2377         //                                              if (name != null && name.length() > 0) {
2378         //                                                      String content= reference.getSource();
2379         //                                                      if (content != null) {
2380         //                                                              offset= range.getOffset() + content.indexOf(name);
2381         //                                                              length= name.length();
2382         //                                                      }
2383         //                                              }
2384         //                                      } else if (reference instanceof IPackageDeclaration) {
2385         //                                              String name= ((IPackageDeclaration)
2386         // reference).getElementName();
2387         //                                              if (name != null && name.length() > 0) {
2388         //                                                      String content= reference.getSource();
2389         //                                                      if (content != null) {
2390         //                                                              offset= range.getOffset() + content.indexOf(name);
2391         //                                                              length= name.length();
2392         //                                                      }
2393         //                                              }
2394         //                                      }
2395
2396         if (offset > -1 && length > 0) {
2397           sourceViewer.revealRange(offset, length);
2398           sourceViewer.setSelectedRange(offset, length);
2399         }
2400
2401       } catch (JavaModelException x) {
2402       } catch (IllegalArgumentException x) {
2403       } finally {
2404         if (textWidget != null)
2405           textWidget.setRedraw(true);
2406       }
2407
2408     } else if (moveCursor) {
2409       resetHighlightRange();
2410     }
2411
2412     markInNavigationHistory();
2413   }
2414
2415   public void setSelection(IJavaElement element) {
2416     if (element == null || element instanceof ICompilationUnit) { // ||
2417       // element
2418       // instanceof
2419       // IClassFile)
2420       // {
2421       /*
2422        * If the element is an ICompilationUnit this unit is either the input of this editor or not being displayed. In both cases,
2423        * nothing should happened. (http://dev.eclipse.org/bugs/show_bug.cgi?id=5128)
2424        */
2425       return;
2426     }
2427
2428     IJavaElement corresponding = getCorrespondingElement(element);
2429     if (corresponding instanceof ISourceReference) {
2430       ISourceReference reference = (ISourceReference) corresponding;
2431       // set highlight range
2432       setSelection(reference, true);
2433       // set outliner selection
2434       if (fOutlinePage != null) {
2435         fOutlineSelectionChangedListener.uninstall(fOutlinePage);
2436         fOutlinePage.select(reference);
2437         fOutlineSelectionChangedListener.install(fOutlinePage);
2438       }
2439     }
2440   }
2441
2442   public synchronized void editingScriptStarted() {
2443     ++fIgnoreOutlinePageSelection;
2444   }
2445
2446   public synchronized void editingScriptEnded() {
2447     --fIgnoreOutlinePageSelection;
2448   }
2449
2450   public synchronized boolean isEditingScriptRunning() {
2451     return (fIgnoreOutlinePageSelection > 0);
2452   }
2453
2454   /**
2455    * The <code>PHPEditor</code> implementation of this <code>AbstractTextEditor</code> method performs gets the java content
2456    * outline page if request is for a an outline page.
2457    */
2458   public Object getAdapter(Class required) {
2459
2460     if (IContentOutlinePage.class.equals(required)) {
2461       if (fOutlinePage == null)
2462         fOutlinePage = createOutlinePage();
2463       return fOutlinePage;
2464     }
2465
2466     if (IEncodingSupport.class.equals(required))
2467       return fEncodingSupport;
2468
2469     if (required == IShowInTargetList.class) {
2470       return new IShowInTargetList() {
2471         public String[] getShowInTargetIds() {
2472           return new String[] { JavaUI.ID_PACKAGES, IPageLayout.ID_OUTLINE, IPageLayout.ID_RES_NAV };
2473         }
2474
2475       };
2476     }
2477     if (fProjectionSupport != null) {
2478       Object adapter = fProjectionSupport.getAdapter(getSourceViewer(), required);
2479       if (adapter != null)
2480         return adapter;
2481     }
2482
2483     return super.getAdapter(required);
2484   }
2485
2486   //  public Object getAdapter(Class required) {
2487   //    if (IContentOutlinePage.class.equals(required)) {
2488   //      if (fOutlinePage == null) {
2489   //        fOutlinePage = new PHPContentOutlinePage(getDocumentProvider(), this);
2490   //        if (getEditorInput() != null)
2491   //          fOutlinePage.setInput(getEditorInput());
2492   //      }
2493   //      return fOutlinePage;
2494   //    }
2495   //
2496   //    if (IEncodingSupport.class.equals(required))
2497   //      return fEncodingSupport;
2498   //
2499   //    return super.getAdapter(required);
2500   //  }
2501
2502   protected void doSelectionChanged(SelectionChangedEvent event) {
2503     ISourceReference reference = null;
2504
2505     ISelection selection = event.getSelection();
2506     Iterator iter = ((IStructuredSelection) selection).iterator();
2507     while (iter.hasNext()) {
2508       Object o = iter.next();
2509       if (o instanceof ISourceReference) {
2510         reference = (ISourceReference) o;
2511         break;
2512       }
2513     }
2514
2515     if (!isActivePart() && PHPeclipsePlugin.getActivePage() != null)
2516       PHPeclipsePlugin.getActivePage().bringToTop(this);
2517
2518     try {
2519       editingScriptStarted();
2520       setSelection(reference, !isActivePart());
2521     } finally {
2522       editingScriptEnded();
2523     }
2524   }
2525
2526   /*
2527    * @see AbstractTextEditor#adjustHighlightRange(int, int)
2528    */
2529   protected void adjustHighlightRange(int offset, int length) {
2530
2531     try {
2532
2533       IJavaElement element = getElementAt(offset);
2534       while (element instanceof ISourceReference) {
2535         ISourceRange range = ((ISourceReference) element).getSourceRange();
2536         if (offset < range.getOffset() + range.getLength() && range.getOffset() < offset + length) {
2537
2538           ISourceViewer viewer = getSourceViewer();
2539           if (viewer instanceof ITextViewerExtension5) {
2540             ITextViewerExtension5 extension = (ITextViewerExtension5) viewer;
2541             extension.exposeModelRange(new Region(range.getOffset(), range.getLength()));
2542           }
2543
2544           setHighlightRange(range.getOffset(), range.getLength(), true);
2545           if (fOutlinePage != null) {
2546             fOutlineSelectionChangedListener.uninstall(fOutlinePage);
2547             fOutlinePage.select((ISourceReference) element);
2548             fOutlineSelectionChangedListener.install(fOutlinePage);
2549           }
2550
2551           return;
2552         }
2553         element = element.getParent();
2554       }
2555
2556     } catch (JavaModelException x) {
2557       PHPeclipsePlugin.log(x.getStatus());
2558     }
2559
2560     ISourceViewer viewer = getSourceViewer();
2561     if (viewer instanceof ITextViewerExtension5) {
2562       ITextViewerExtension5 extension = (ITextViewerExtension5) viewer;
2563       extension.exposeModelRange(new Region(offset, length));
2564     } else {
2565       resetHighlightRange();
2566     }
2567
2568   }
2569
2570   protected boolean isActivePart() {
2571     IWorkbenchWindow window = getSite().getWorkbenchWindow();
2572     IPartService service = window.getPartService();
2573     IWorkbenchPart part = service.getActivePart();
2574     return part != null && part.equals(this);
2575   }
2576
2577   //  public void openContextHelp() {
2578   //    IDocument doc =
2579   // this.getDocumentProvider().getDocument(this.getEditorInput());
2580   //    ITextSelection selection = (ITextSelection)
2581   // this.getSelectionProvider().getSelection();
2582   //    int pos = selection.getOffset();
2583   //    String word = getFunctionName(doc, pos);
2584   //    openContextHelp(word);
2585   //  }
2586   //
2587   //  private void openContextHelp(String word) {
2588   //    open(word);
2589   //  }
2590   //
2591   //  public static void open(String word) {
2592   //    IHelp help = WorkbenchHelp.getHelpSupport();
2593   //    if (help != null) {
2594   //      IHelpResource helpResource = new PHPFunctionHelpResource(word);
2595   //      WorkbenchHelp.getHelpSupport().displayHelpResource(helpResource);
2596   //    } else {
2597   //      // showMessage(shell, dialogTitle, ActionMessages.getString("Open help
2598   // not available"), false); //$NON-NLS-1$
2599   //    }
2600   //  }
2601
2602   //    private String getFunctionName(IDocument doc, int pos) {
2603   //            Point word = PHPWordExtractor.findWord(doc, pos);
2604   //            if (word != null) {
2605   //                    try {
2606   //                            return doc.get(word.x, word.y).replace('_', '-');
2607   //                    } catch (BadLocationException e) {
2608   //                    }
2609   //            }
2610   //            return "";
2611   //    }
2612
2613   /*
2614    * @see AbstractTextEditor#handlePreferenceStoreChanged(PropertyChangeEvent)
2615    */
2616   protected void handlePreferenceStoreChanged(PropertyChangeEvent event) {
2617
2618     try {
2619
2620       ISourceViewer sourceViewer = getSourceViewer();
2621       if (sourceViewer == null)
2622         return;
2623
2624       String property = event.getProperty();
2625
2626       if (PreferenceConstants.EDITOR_TAB_WIDTH.equals(property)) {
2627         Object value = event.getNewValue();
2628         if (value instanceof Integer) {
2629           sourceViewer.getTextWidget().setTabs(((Integer) value).intValue());
2630         } else if (value instanceof String) {
2631           sourceViewer.getTextWidget().setTabs(Integer.parseInt((String) value));
2632         }
2633         return;
2634       }
2635
2636       //      if (OVERVIEW_RULER.equals(property)) {
2637       //        if (isOverviewRulerVisible())
2638       //          showOverviewRuler();
2639       //        else
2640       //          hideOverviewRuler();
2641       //        return;
2642       //      }
2643
2644       //      if (LINE_NUMBER_RULER.equals(property)) {
2645       //        if (isLineNumberRulerVisible())
2646       //          showLineNumberRuler();
2647       //        else
2648       //          hideLineNumberRuler();
2649       //        return;
2650       //      }
2651
2652       //      if (fLineNumberRulerColumn != null
2653       //        && (LINE_NUMBER_COLOR.equals(property) ||
2654       // PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT.equals(property) ||
2655       // PREFERENCE_COLOR_BACKGROUND.equals(property))) {
2656       //
2657       //        initializeLineNumberRulerColumn(fLineNumberRulerColumn);
2658       //      }
2659
2660       if (isJavaEditorHoverProperty(property))
2661         updateHoverBehavior();
2662
2663       if (BROWSER_LIKE_LINKS.equals(property)) {
2664         if (isBrowserLikeLinks())
2665           enableBrowserLikeLinks();
2666         else
2667           disableBrowserLikeLinks();
2668         return;
2669       }
2670
2671       //      if
2672       // (PreferenceConstants.EDITOR_SYNC_OUTLINE_ON_CURSOR_MOVE.equals(property))
2673       // {
2674       //                if ((event.getNewValue() instanceof Boolean) &&
2675       // ((Boolean)event.getNewValue()).booleanValue())
2676       //                        fEditorSelectionChangedListener.selectionChanged();
2677       //                return;
2678       //        }
2679
2680       if (PreferenceConstants.EDITOR_DISABLE_OVERWRITE_MODE.equals(property)) {
2681         if (event.getNewValue() instanceof Boolean) {
2682           Boolean disable = (Boolean) event.getNewValue();
2683           enableOverwriteMode(!disable.booleanValue());
2684         }
2685         return;
2686       }
2687
2688       //        if (PreferenceConstants.EDITOR_MARK_OCCURRENCES.equals(property))
2689       // {
2690       //                if (event.getNewValue() instanceof Boolean) {
2691       //                        boolean markOccurrenceAnnotations=
2692       // ((Boolean)event.getNewValue()).booleanValue();
2693       //                        if (markOccurrenceAnnotations != fMarkOccurrenceAnnotations) {
2694       //                                fMarkOccurrenceAnnotations= markOccurrenceAnnotations;
2695       //                                if (!fMarkOccurrenceAnnotations)
2696       //                                        uninstallOccurrencesFinder();
2697       //                                else
2698       //                                        installOccurrencesFinder();
2699       //                        }
2700       //                }
2701       //        }
2702       //        if
2703       // (PreferenceConstants.EDITOR_STICKY_OCCURRENCES.equals(property))
2704       // {
2705       //                if (event.getNewValue() instanceof Boolean) {
2706       //                        boolean stickyOccurrenceAnnotations=
2707       // ((Boolean)event.getNewValue()).booleanValue();
2708       //                        if (stickyOccurrenceAnnotations != fStickyOccurrenceAnnotations)
2709       // {
2710       //                                fStickyOccurrenceAnnotations= stickyOccurrenceAnnotations;
2711       //// if (!fMarkOccurrenceAnnotations)
2712       //// uninstallOccurrencesFinder();
2713       //// else
2714       //// installOccurrencesFinder();
2715       //                        }
2716       //                }
2717       //        }
2718       if (PreferenceConstants.EDITOR_FOLDING_PROVIDER.equals(property)) {
2719         if (sourceViewer instanceof ProjectionViewer) {
2720           ProjectionViewer projectionViewer = (ProjectionViewer) sourceViewer;
2721           if (fProjectionModelUpdater != null)
2722             fProjectionModelUpdater.uninstall();
2723           // either freshly enabled or provider changed
2724           fProjectionModelUpdater = PHPeclipsePlugin.getDefault().getFoldingStructureProviderRegistry().getCurrentFoldingProvider();
2725           if (fProjectionModelUpdater != null) {
2726             fProjectionModelUpdater.install(this, projectionViewer);
2727           }
2728         }
2729         return;
2730       }
2731     } finally {
2732       super.handlePreferenceStoreChanged(event);
2733     }
2734   }
2735
2736   //  /*
2737   //     * @see
2738   // AbstractTextEditor#handlePreferenceStoreChanged(PropertyChangeEvent)
2739   //     */
2740   //  protected void handlePreferenceStoreChanged(PropertyChangeEvent event) {
2741   //
2742   //    try {
2743   //
2744   //      ISourceViewer sourceViewer = getSourceViewer();
2745   //      if (sourceViewer == null)
2746   //        return;
2747   //
2748   //      String property = event.getProperty();
2749   //
2750   //      // if
2751   // (JavaSourceViewerConfiguration.PREFERENCE_TAB_WIDTH.equals(property)) {
2752   //      // Object value= event.getNewValue();
2753   //      // if (value instanceof Integer) {
2754   //      // sourceViewer.getTextWidget().setTabs(((Integer) value).intValue());
2755   //      // } else if (value instanceof String) {
2756   //      // sourceViewer.getTextWidget().setTabs(Integer.parseInt((String)
2757   // value));
2758   //      // }
2759   //      // return;
2760   //      // }
2761   //
2762   //      if (IPreferenceConstants.LINE_NUMBER_RULER.equals(property)) {
2763   //        if (isLineNumberRulerVisible())
2764   //          showLineNumberRuler();
2765   //        else
2766   //          hideLineNumberRuler();
2767   //        return;
2768   //      }
2769   //
2770   //      if (fLineNumberRulerColumn != null
2771   //        && (IPreferenceConstants.LINE_NUMBER_COLOR.equals(property)
2772   //          || PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT.equals(property)
2773   //          || PREFERENCE_COLOR_BACKGROUND.equals(property))) {
2774   //
2775   //        initializeLineNumberRulerColumn(fLineNumberRulerColumn);
2776   //      }
2777   //
2778   //    } finally {
2779   //      super.handlePreferenceStoreChanged(event);
2780   //    }
2781   //  }
2782
2783   //  private boolean isJavaEditorHoverProperty(String property) {
2784   //    return PreferenceConstants.EDITOR_DEFAULT_HOVER.equals(property)
2785   //      || PreferenceConstants.EDITOR_NONE_HOVER.equals(property)
2786   //      || PreferenceConstants.EDITOR_CTRL_HOVER.equals(property)
2787   //      || PreferenceConstants.EDITOR_SHIFT_HOVER.equals(property)
2788   //      || PreferenceConstants.EDITOR_CTRL_ALT_HOVER.equals(property)
2789   //      || PreferenceConstants.EDITOR_CTRL_SHIFT_HOVER.equals(property)
2790   //      || PreferenceConstants.EDITOR_CTRL_ALT_SHIFT_HOVER.equals(property)
2791   //      || PreferenceConstants.EDITOR_ALT_SHIFT_HOVER.equals(property);
2792   //  }
2793
2794   /**
2795    * Shows the line number ruler column.
2796    */
2797   //  private void showLineNumberRuler() {
2798   //    IVerticalRuler v = getVerticalRuler();
2799   //    if (v instanceof CompositeRuler) {
2800   //      CompositeRuler c = (CompositeRuler) v;
2801   //      c.addDecorator(1, createLineNumberRulerColumn());
2802   //    }
2803   //  }
2804   private boolean isJavaEditorHoverProperty(String property) {
2805     return PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIERS.equals(property);
2806   }
2807
2808   /**
2809    * Return whether the browser like links should be enabled according to the preference store settings.
2810    *
2811    * @return <code>true</code> if the browser like links should be enabled
2812    */
2813   private boolean isBrowserLikeLinks() {
2814     IPreferenceStore store = getPreferenceStore();
2815     return store.getBoolean(BROWSER_LIKE_LINKS);
2816   }
2817
2818   /**
2819    * Enables browser like links.
2820    */
2821   private void enableBrowserLikeLinks() {
2822     if (fMouseListener == null) {
2823       fMouseListener = new MouseClickListener();
2824       fMouseListener.install();
2825     }
2826   }
2827
2828   /**
2829    * Disables browser like links.
2830    */
2831   private void disableBrowserLikeLinks() {
2832     if (fMouseListener != null) {
2833       fMouseListener.uninstall();
2834       fMouseListener = null;
2835     }
2836   }
2837
2838   /**
2839    * Handles a property change event describing a change of the java core's preferences and updates the preference related editor
2840    * properties.
2841    *
2842    * @param event
2843    *          the property change event
2844    */
2845   protected void handlePreferencePropertyChanged(org.eclipse.core.runtime.Preferences.PropertyChangeEvent event) {
2846     if (COMPILER_TASK_TAGS.equals(event.getProperty())) {
2847       ISourceViewer sourceViewer = getSourceViewer();
2848       if (sourceViewer != null
2849           && affectsTextPresentation(new PropertyChangeEvent(event.getSource(), event.getProperty(), event.getOldValue(), event
2850               .getNewValue())))
2851         sourceViewer.invalidateTextPresentation();
2852     }
2853   }
2854
2855   /**
2856    * Return whether the line number ruler column should be visible according to the preference store settings.
2857    *
2858    * @return <code>true</code> if the line numbers should be visible
2859    */
2860   //  protected boolean isLineNumberRulerVisible() {
2861   //    IPreferenceStore store = getPreferenceStore();
2862   //    return store.getBoolean(LINE_NUMBER_RULER);
2863   //  }
2864   /**
2865    * Hides the line number ruler column.
2866    */
2867   //  private void hideLineNumberRuler() {
2868   //    IVerticalRuler v = getVerticalRuler();
2869   //    if (v instanceof CompositeRuler) {
2870   //      CompositeRuler c = (CompositeRuler) v;
2871   //      try {
2872   //        c.removeDecorator(1);
2873   //      } catch (Throwable e) {
2874   //      }
2875   //    }
2876   //  }
2877   /*
2878    * @see AbstractTextEditor#handleCursorPositionChanged()
2879    */
2880   protected void handleCursorPositionChanged() {
2881     super.handleCursorPositionChanged();
2882     if (!isEditingScriptRunning() && fUpdater != null)
2883       fUpdater.post();
2884   }
2885
2886   /*
2887    * @see org.eclipse.ui.texteditor.AbstractTextEditor#handleElementContentReplaced()
2888    */
2889   protected void handleElementContentReplaced() {
2890     super.handleElementContentReplaced();
2891     if (fProjectionModelUpdater != null)
2892       fProjectionModelUpdater.initialize();
2893   }
2894
2895   /**
2896    * Initializes the given line number ruler column from the preference store.
2897    *
2898    * @param rulerColumn
2899    *          the ruler column to be initialized
2900    */
2901   //  protected void initializeLineNumberRulerColumn(LineNumberRulerColumn
2902   // rulerColumn) {
2903   //    JavaTextTools textTools =
2904   // PHPeclipsePlugin.getDefault().getJavaTextTools();
2905   //    IColorManager manager = textTools.getColorManager();
2906   //
2907   //    IPreferenceStore store = getPreferenceStore();
2908   //    if (store != null) {
2909   //
2910   //      RGB rgb = null;
2911   //      // foreground color
2912   //      if (store.contains(LINE_NUMBER_COLOR)) {
2913   //        if (store.isDefault(LINE_NUMBER_COLOR))
2914   //          rgb = PreferenceConverter.getDefaultColor(store, LINE_NUMBER_COLOR);
2915   //        else
2916   //          rgb = PreferenceConverter.getColor(store, LINE_NUMBER_COLOR);
2917   //      }
2918   //      rulerColumn.setForeground(manager.getColor(rgb));
2919   //
2920   //      rgb = null;
2921   //      // background color
2922   //      if (!store.getBoolean(PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT)) {
2923   //        if (store.contains(PREFERENCE_COLOR_BACKGROUND)) {
2924   //          if (store.isDefault(PREFERENCE_COLOR_BACKGROUND))
2925   //            rgb = PreferenceConverter.getDefaultColor(store,
2926   // PREFERENCE_COLOR_BACKGROUND);
2927   //          else
2928   //            rgb = PreferenceConverter.getColor(store, PREFERENCE_COLOR_BACKGROUND);
2929   //        }
2930   //      }
2931   //      rulerColumn.setBackground(manager.getColor(rgb));
2932   //    }
2933   //  }
2934   /**
2935    * Creates a new line number ruler column that is appropriately initialized.
2936    */
2937   //  protected IVerticalRulerColumn createLineNumberRulerColumn() {
2938   //    fLineNumberRulerColumn = new LineNumberRulerColumn();
2939   //    initializeLineNumberRulerColumn(fLineNumberRulerColumn);
2940   //    return fLineNumberRulerColumn;
2941   //  }
2942   /*
2943    * @see AbstractTextEditor#createVerticalRuler()
2944    */
2945   //  protected IVerticalRuler createVerticalRuler() {
2946   //    CompositeRuler ruler = new CompositeRuler();
2947   //    ruler.addDecorator(0, new AnnotationRulerColumn(VERTICAL_RULER_WIDTH));
2948   //    if (isLineNumberRulerVisible())
2949   //      ruler.addDecorator(1, createLineNumberRulerColumn());
2950   //    return ruler;
2951   //  }
2952 //  private static IRegion getSignedSelection(ITextViewer viewer) {
2953 //
2954 //    StyledText text = viewer.getTextWidget();
2955 //    int caretOffset = text.getCaretOffset();
2956 //    Point selection = text.getSelection();
2957 //
2958 //    // caret left
2959 //    int offset, length;
2960 //    if (caretOffset == selection.x) {
2961 //      offset = selection.y;
2962 //      length = selection.x - selection.y;
2963 //
2964 //      // caret right
2965 //    } else {
2966 //      offset = selection.x;
2967 //      length = selection.y - selection.x;
2968 //    }
2969 //
2970 //    return new Region(offset, length);
2971 //  }
2972         protected IRegion getSignedSelection(ISourceViewer sourceViewer) {
2973                 StyledText text= sourceViewer.getTextWidget();
2974                 Point selection= text.getSelectionRange();
2975
2976                 if (text.getCaretOffset() == selection.x) {
2977                         selection.x= selection.x + selection.y;
2978                         selection.y= -selection.y;
2979                 }
2980
2981                 selection.x= widgetOffset2ModelOffset(sourceViewer, selection.x);
2982
2983                 return new Region(selection.x, selection.y);
2984         }
2985   /** Preference key for matching brackets */
2986   protected final static String MATCHING_BRACKETS = PreferenceConstants.EDITOR_MATCHING_BRACKETS;
2987
2988   /** Preference key for matching brackets color */
2989   protected final static String MATCHING_BRACKETS_COLOR = PreferenceConstants.EDITOR_MATCHING_BRACKETS_COLOR;
2990
2991   /** Preference key for highlighting current line */
2992   protected final static String CURRENT_LINE = PreferenceConstants.EDITOR_CURRENT_LINE;
2993
2994   /** Preference key for highlight color of current line */
2995   protected final static String CURRENT_LINE_COLOR = PreferenceConstants.EDITOR_CURRENT_LINE_COLOR;
2996
2997   /** Preference key for showing print marging ruler */
2998   protected final static String PRINT_MARGIN = PreferenceConstants.EDITOR_PRINT_MARGIN;
2999
3000   /** Preference key for print margin ruler color */
3001   protected final static String PRINT_MARGIN_COLOR = PreferenceConstants.EDITOR_PRINT_MARGIN_COLOR;
3002
3003   /** Preference key for print margin ruler column */
3004   protected final static String PRINT_MARGIN_COLUMN = PreferenceConstants.EDITOR_PRINT_MARGIN_COLUMN;
3005
3006   /** Preference key for error indication */
3007   //  protected final static String ERROR_INDICATION =
3008   // PreferenceConstants.EDITOR_PROBLEM_INDICATION;
3009   /** Preference key for error color */
3010   //  protected final static String ERROR_INDICATION_COLOR =
3011   // PreferenceConstants.EDITOR_PROBLEM_INDICATION_COLOR;
3012   /** Preference key for warning indication */
3013   //  protected final static String WARNING_INDICATION =
3014   // PreferenceConstants.EDITOR_WARNING_INDICATION;
3015   /** Preference key for warning color */
3016   //  protected final static String WARNING_INDICATION_COLOR =
3017   // PreferenceConstants.EDITOR_WARNING_INDICATION_COLOR;
3018   /** Preference key for task indication */
3019   protected final static String TASK_INDICATION = PreferenceConstants.EDITOR_TASK_INDICATION;
3020
3021   /** Preference key for task color */
3022   protected final static String TASK_INDICATION_COLOR = PreferenceConstants.EDITOR_TASK_INDICATION_COLOR;
3023
3024   /** Preference key for bookmark indication */
3025   protected final static String BOOKMARK_INDICATION = PreferenceConstants.EDITOR_BOOKMARK_INDICATION;
3026
3027   /** Preference key for bookmark color */
3028   protected final static String BOOKMARK_INDICATION_COLOR = PreferenceConstants.EDITOR_BOOKMARK_INDICATION_COLOR;
3029
3030   /** Preference key for search result indication */
3031   protected final static String SEARCH_RESULT_INDICATION = PreferenceConstants.EDITOR_SEARCH_RESULT_INDICATION;
3032
3033   /** Preference key for search result color */
3034   protected final static String SEARCH_RESULT_INDICATION_COLOR = PreferenceConstants.EDITOR_SEARCH_RESULT_INDICATION_COLOR;
3035
3036   /** Preference key for unknown annotation indication */
3037   protected final static String UNKNOWN_INDICATION = PreferenceConstants.EDITOR_UNKNOWN_INDICATION;
3038
3039   /** Preference key for unknown annotation color */
3040   protected final static String UNKNOWN_INDICATION_COLOR = PreferenceConstants.EDITOR_UNKNOWN_INDICATION_COLOR;
3041
3042   /** Preference key for shwoing the overview ruler */
3043   protected final static String OVERVIEW_RULER = PreferenceConstants.EDITOR_OVERVIEW_RULER;
3044
3045   /** Preference key for error indication in overview ruler */
3046   protected final static String ERROR_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_ERROR_INDICATION_IN_OVERVIEW_RULER;
3047
3048   /** Preference key for warning indication in overview ruler */
3049   protected final static String WARNING_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_WARNING_INDICATION_IN_OVERVIEW_RULER;
3050
3051   /** Preference key for task indication in overview ruler */
3052   protected final static String TASK_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_TASK_INDICATION_IN_OVERVIEW_RULER;
3053
3054   /** Preference key for bookmark indication in overview ruler */
3055   protected final static String BOOKMARK_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_BOOKMARK_INDICATION_IN_OVERVIEW_RULER;
3056
3057   /** Preference key for search result indication in overview ruler */
3058   protected final static String SEARCH_RESULT_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_SEARCH_RESULT_INDICATION_IN_OVERVIEW_RULER;
3059
3060   /** Preference key for unknown annotation indication in overview ruler */
3061   protected final static String UNKNOWN_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_UNKNOWN_INDICATION_IN_OVERVIEW_RULER;
3062
3063   //            /** Preference key for compiler task tags */
3064   //            private final static String COMPILER_TASK_TAGS=
3065   // JavaCore.COMPILER_TASK_TAGS;
3066   /** Preference key for browser like links */
3067   private final static String BROWSER_LIKE_LINKS = PreferenceConstants.EDITOR_BROWSER_LIKE_LINKS;
3068
3069   /** Preference key for key modifier of browser like links */
3070   private final static String BROWSER_LIKE_LINKS_KEY_MODIFIER = PreferenceConstants.EDITOR_BROWSER_LIKE_LINKS_KEY_MODIFIER;
3071
3072   /**
3073    * Preference key for key modifier mask of browser like links. The value is only used if the value of
3074    * <code>EDITOR_BROWSER_LIKE_LINKS</code> cannot be resolved to valid SWT modifier bits.
3075    *
3076    * @since 2.1.1
3077    */
3078   private final static String BROWSER_LIKE_LINKS_KEY_MODIFIER_MASK = PreferenceConstants.EDITOR_BROWSER_LIKE_LINKS_KEY_MODIFIER_MASK;
3079
3080   private final static char[] BRACKETS = { '{', '}', '(', ')', '[', ']' };
3081
3082   private static boolean isBracket(char character) {
3083     for (int i = 0; i != BRACKETS.length; ++i)
3084       if (character == BRACKETS[i])
3085         return true;
3086     return false;
3087   }
3088
3089   private static boolean isSurroundedByBrackets(IDocument document, int offset) {
3090     if (offset == 0 || offset == document.getLength())
3091       return false;
3092
3093     try {
3094       return isBracket(document.getChar(offset - 1)) && isBracket(document.getChar(offset));
3095
3096     } catch (BadLocationException e) {
3097       return false;
3098     }
3099   }
3100
3101   //  protected void configureSourceViewerDecorationSupport() {
3102   //
3103   //    fSourceViewerDecorationSupport.setCharacterPairMatcher(fBracketMatcher);
3104   //
3105   //    fSourceViewerDecorationSupport.setAnnotationPainterPreferenceKeys(
3106   //      AnnotationType.UNKNOWN,
3107   //      UNKNOWN_INDICATION_COLOR,
3108   //      UNKNOWN_INDICATION,
3109   //      UNKNOWN_INDICATION_IN_OVERVIEW_RULER,
3110   //      0);
3111   //    fSourceViewerDecorationSupport.setAnnotationPainterPreferenceKeys(
3112   //      AnnotationType.BOOKMARK,
3113   //      BOOKMARK_INDICATION_COLOR,
3114   //      BOOKMARK_INDICATION,
3115   //      BOOKMARK_INDICATION_IN_OVERVIEW_RULER,
3116   //      1);
3117   //    fSourceViewerDecorationSupport.setAnnotationPainterPreferenceKeys(
3118   //      AnnotationType.TASK,
3119   //      TASK_INDICATION_COLOR,
3120   //      TASK_INDICATION,
3121   //      TASK_INDICATION_IN_OVERVIEW_RULER,
3122   //      2);
3123   //    fSourceViewerDecorationSupport.setAnnotationPainterPreferenceKeys(
3124   //      AnnotationType.SEARCH,
3125   //      SEARCH_RESULT_INDICATION_COLOR,
3126   //      SEARCH_RESULT_INDICATION,
3127   //      SEARCH_RESULT_INDICATION_IN_OVERVIEW_RULER,
3128   //      3);
3129   //    fSourceViewerDecorationSupport.setAnnotationPainterPreferenceKeys(
3130   //      AnnotationType.WARNING,
3131   //      WARNING_INDICATION_COLOR,
3132   //      WARNING_INDICATION,
3133   //      WARNING_INDICATION_IN_OVERVIEW_RULER,
3134   //      4);
3135   //    fSourceViewerDecorationSupport.setAnnotationPainterPreferenceKeys(
3136   //      AnnotationType.ERROR,
3137   //      ERROR_INDICATION_COLOR,
3138   //      ERROR_INDICATION,
3139   //      ERROR_INDICATION_IN_OVERVIEW_RULER,
3140   //      5);
3141   //
3142   //    fSourceViewerDecorationSupport.setCursorLinePainterPreferenceKeys(CURRENT_LINE,
3143   // CURRENT_LINE_COLOR);
3144   //    fSourceViewerDecorationSupport.setMarginPainterPreferenceKeys(PRINT_MARGIN,
3145   // PRINT_MARGIN_COLOR, PRINT_MARGIN_COLUMN);
3146   //    fSourceViewerDecorationSupport.setMatchingCharacterPainterPreferenceKeys(MATCHING_BRACKETS,
3147   // MATCHING_BRACKETS_COLOR);
3148   //
3149   //    fSourceViewerDecorationSupport.setSymbolicFontName(getFontPropertyPreferenceKey());
3150   //
3151   //  }
3152   /**
3153    * Returns the Java element wrapped by this editors input.
3154    *
3155    * @return the Java element wrapped by this editors input.
3156    * @since 3.0
3157    */
3158   abstract protected IJavaElement getInputJavaElement();
3159
3160   /**
3161    * Jumps to the matching bracket.
3162    */
3163   public void gotoMatchingBracket() {
3164
3165     ISourceViewer sourceViewer = getSourceViewer();
3166     IDocument document = sourceViewer.getDocument();
3167     if (document == null)
3168       return;
3169
3170     IRegion selection = getSignedSelection(sourceViewer);
3171
3172     int selectionLength = Math.abs(selection.getLength());
3173     if (selectionLength > 1) {
3174       setStatusLineErrorMessage(PHPEditorMessages.getString("GotoMatchingBracket.error.invalidSelection")); //$NON-NLS-1$
3175       sourceViewer.getTextWidget().getDisplay().beep();
3176       return;
3177     }
3178
3179     // #26314
3180     int sourceCaretOffset = selection.getOffset() + selection.getLength();
3181     if (isSurroundedByBrackets(document, sourceCaretOffset))
3182       sourceCaretOffset -= selection.getLength();
3183
3184     IRegion region = fBracketMatcher.match(document, sourceCaretOffset);
3185     if (region == null) {
3186       setStatusLineErrorMessage(PHPEditorMessages.getString("GotoMatchingBracket.error.noMatchingBracket")); //$NON-NLS-1$
3187       sourceViewer.getTextWidget().getDisplay().beep();
3188       return;
3189     }
3190
3191     int offset = region.getOffset();
3192     int length = region.getLength();
3193
3194     if (length < 1)
3195       return;
3196
3197     int anchor = fBracketMatcher.getAnchor();
3198     int targetOffset = (PHPPairMatcher.RIGHT == anchor) ? offset : offset + length - 1;
3199
3200     boolean visible = false;
3201     if (sourceViewer instanceof ITextViewerExtension3) {
3202       ITextViewerExtension3 extension = (ITextViewerExtension3) sourceViewer;
3203       visible = (extension.modelOffset2WidgetOffset(targetOffset) > -1);
3204     } else {
3205       IRegion visibleRegion = sourceViewer.getVisibleRegion();
3206       visible = (targetOffset >= visibleRegion.getOffset() && targetOffset < visibleRegion.getOffset() + visibleRegion.getLength());
3207     }
3208
3209     if (!visible) {
3210       setStatusLineErrorMessage(PHPEditorMessages.getString("GotoMatchingBracket.error.bracketOutsideSelectedElement")); //$NON-NLS-1$
3211       sourceViewer.getTextWidget().getDisplay().beep();
3212       return;
3213     }
3214
3215     if (selection.getLength() < 0)
3216       targetOffset -= selection.getLength();
3217
3218     sourceViewer.setSelectedRange(targetOffset, selection.getLength());
3219     sourceViewer.revealRange(targetOffset, selection.getLength());
3220   }
3221
3222   /**
3223    * Ses the given message as error message to this editor's status line.
3224    *
3225    * @param msg
3226    *          message to be set
3227    */
3228   protected void setStatusLineErrorMessage(String msg) {
3229     IEditorStatusLine statusLine = (IEditorStatusLine) getAdapter(IEditorStatusLine.class);
3230     if (statusLine != null)
3231       statusLine.setMessage(true, msg, null);
3232   }
3233
3234   /**
3235    * Returns a segmentation of the line of the given document appropriate for bidi rendering. The default implementation returns
3236    * only the string literals of a php code line as segments.
3237    *
3238    * @param document
3239    *          the document
3240    * @param lineOffset
3241    *          the offset of the line
3242    * @return the line's bidi segmentation
3243    * @throws BadLocationException
3244    *           in case lineOffset is not valid in document
3245    */
3246   public static int[] getBidiLineSegments(IDocument document, int lineOffset) throws BadLocationException {
3247
3248     IRegion line = document.getLineInformationOfOffset(lineOffset);
3249     ITypedRegion[] linePartitioning = document.computePartitioning(lineOffset, line.getLength());
3250
3251     List segmentation = new ArrayList();
3252     for (int i = 0; i < linePartitioning.length; i++) {
3253       if (IPHPPartitions.PHP_STRING_DQ.equals(linePartitioning[i].getType()))
3254         segmentation.add(linePartitioning[i]);
3255     }
3256
3257     if (segmentation.size() == 0)
3258       return null;
3259
3260     int size = segmentation.size();
3261     int[] segments = new int[size * 2 + 1];
3262
3263     int j = 0;
3264     for (int i = 0; i < size; i++) {
3265       ITypedRegion segment = (ITypedRegion) segmentation.get(i);
3266
3267       if (i == 0)
3268         segments[j++] = 0;
3269
3270       int offset = segment.getOffset() - lineOffset;
3271       if (offset > segments[j - 1])
3272         segments[j++] = offset;
3273
3274       if (offset + segment.getLength() >= line.getLength())
3275         break;
3276
3277       segments[j++] = offset + segment.getLength();
3278     }
3279
3280     if (j < segments.length) {
3281       int[] result = new int[j];
3282       System.arraycopy(segments, 0, result, 0, j);
3283       segments = result;
3284     }
3285
3286     return segments;
3287   }
3288
3289   /**
3290    * Returns a segmentation of the given line appropriate for bidi rendering. The default implementation returns only the string
3291    * literals of a php code line as segments.
3292    *
3293    * @param lineOffset
3294    *          the offset of the line
3295    * @param line
3296    *          the content of the line
3297    * @return the line's bidi segmentation
3298    */
3299   protected int[] getBidiLineSegments(int lineOffset, String line) {
3300     IDocumentProvider provider = getDocumentProvider();
3301     if (provider != null && line != null && line.length() > 0) {
3302       IDocument document = provider.getDocument(getEditorInput());
3303       if (document != null)
3304         try {
3305           return getBidiLineSegments(document, lineOffset);
3306         } catch (BadLocationException x) {
3307           // ignore
3308         }
3309     }
3310     return null;
3311   }
3312
3313   /*
3314    * @see AbstractTextEditor#createSourceViewer(Composite, IVerticalRuler, int)
3315    */
3316   //  protected final ISourceViewer createSourceViewer(
3317   //    Composite parent,
3318   //    IVerticalRuler ruler,
3319   //    int styles) {
3320   //    ISourceViewer viewer = createJavaSourceViewer(parent, ruler, styles);
3321   //    StyledText text = viewer.getTextWidget();
3322   //    text.addBidiSegmentListener(new BidiSegmentListener() {
3323   //      public void lineGetSegments(BidiSegmentEvent event) {
3324   //        event.segments = getBidiLineSegments(event.lineOffset, event.lineText);
3325   //      }
3326   //    });
3327   //    // JavaUIHelp.setHelp(this, text, IJavaHelpContextIds.JAVA_EDITOR);
3328   //    return viewer;
3329   //  }
3330   public final ISourceViewer getViewer() {
3331     return getSourceViewer();
3332   }
3333
3334   //  protected void showOverviewRuler() {
3335   //    if (fOverviewRuler != null) {
3336   //      if (getSourceViewer() instanceof ISourceViewerExtension) {
3337   //        ((ISourceViewerExtension)
3338   // getSourceViewer()).showAnnotationsOverview(true);
3339   //        fSourceViewerDecorationSupport.updateOverviewDecorations();
3340   //      }
3341   //    }
3342   //  }
3343   //
3344   //  protected void hideOverviewRuler() {
3345   //    if (getSourceViewer() instanceof ISourceViewerExtension) {
3346   //      fSourceViewerDecorationSupport.hideAnnotationOverview();
3347   //      ((ISourceViewerExtension)
3348   // getSourceViewer()).showAnnotationsOverview(false);
3349   //    }
3350   //  }
3351
3352   //  protected boolean isOverviewRulerVisible() {
3353   //    IPreferenceStore store = getPreferenceStore();
3354   //    return store.getBoolean(OVERVIEW_RULER);
3355   //  }
3356   /*
3357    * @see AbstractTextEditor#createSourceViewer(Composite, IVerticalRuler, int)
3358    */
3359   //  protected ISourceViewer createJavaSourceViewer(
3360   //    Composite parent,
3361   //    IVerticalRuler ruler,
3362   //    IOverviewRuler overviewRuler,
3363   //    boolean isOverviewRulerVisible,
3364   //    int styles) {
3365   //    return new SourceViewer(parent, ruler, overviewRuler,
3366   // isOverviewRulerVisible(), styles);
3367   //  }
3368   /*
3369    * @see AbstractTextEditor#createSourceViewer(Composite, IVerticalRuler, int)
3370    */
3371   protected ISourceViewer createJavaSourceViewer(Composite parent, IVerticalRuler verticalRuler, IOverviewRuler overviewRuler,
3372       boolean isOverviewRulerVisible, int styles, IPreferenceStore store) {
3373     return new JavaSourceViewer(parent, verticalRuler, getOverviewRuler(), isOverviewRulerVisible(), styles, store);
3374   }
3375
3376   /*
3377    * @see AbstractTextEditor#createSourceViewer(Composite, IVerticalRuler, int)
3378    */
3379   protected final ISourceViewer createSourceViewer(Composite parent, IVerticalRuler verticalRuler, int styles) {
3380
3381     ISourceViewer viewer = createJavaSourceViewer(parent, verticalRuler, getOverviewRuler(), isOverviewRulerVisible(), styles,
3382         getPreferenceStore());
3383
3384     StyledText text = viewer.getTextWidget();
3385     text.addBidiSegmentListener(new BidiSegmentListener() {
3386       public void lineGetSegments(BidiSegmentEvent event) {
3387         event.segments = getBidiLineSegments(event.lineOffset, event.lineText);
3388       }
3389     });
3390
3391     //          JavaUIHelp.setHelp(this, text, IJavaHelpContextIds.JAVA_EDITOR);
3392
3393     // ensure source viewer decoration support has been created and
3394     // configured
3395     getSourceViewerDecorationSupport(viewer);
3396
3397     return viewer;
3398   }
3399
3400   /**
3401    * Creates and returns the preference store for this Java editor with the given input.
3402    *
3403    * @param input
3404    *          The editor input for which to create the preference store
3405    * @return the preference store for this editor
3406    *
3407    * @since 3.0
3408    */
3409   private IPreferenceStore createCombinedPreferenceStore(IEditorInput input) {
3410     List stores = new ArrayList(3);
3411
3412     IJavaProject project = EditorUtility.getJavaProject(input);
3413     if (project != null)
3414       stores.add(new OptionsAdapter(project.getOptions(false), PHPeclipsePlugin.getDefault().getMockupPreferenceStore(),
3415           new OptionsAdapter.IPropertyChangeEventFilter() {
3416
3417             public boolean isFiltered(PropertyChangeEvent event) {
3418               IJavaElement inputJavaElement = getInputJavaElement();
3419               IJavaProject javaProject = inputJavaElement != null ? inputJavaElement.getJavaProject() : null;
3420               if (javaProject == null)
3421                 return true;
3422
3423               return !javaProject.getProject().equals(event.getSource());
3424             }
3425
3426           }));
3427
3428     stores.add(PHPeclipsePlugin.getDefault().getPreferenceStore());
3429     stores.add(new PreferencesAdapter(JavaCore.getPlugin().getPluginPreferences()));
3430     stores.add(EditorsUI.getPreferenceStore());
3431
3432     return new ChainedPreferenceStore((IPreferenceStore[]) stores.toArray(new IPreferenceStore[stores.size()]));
3433   }
3434
3435   /*
3436    * @see AbstractTextEditor#createSourceViewer(Composite, IVerticalRuler, int)
3437    */
3438   //    protected ISourceViewer createJavaSourceViewer(Composite parent,
3439   // IVerticalRuler verticalRuler, IOverviewRuler overviewRuler, boolean
3440   // isOverviewRulerVisible, int styles) {
3441   //            return new JavaSourceViewer(parent, verticalRuler, getOverviewRuler(),
3442   // isOverviewRulerVisible(), styles);
3443   //    }
3444   /*
3445    * @see AbstractTextEditor#affectsTextPresentation(PropertyChangeEvent)
3446    */
3447   protected boolean affectsTextPresentation(PropertyChangeEvent event) {
3448     JavaTextTools textTools = PHPeclipsePlugin.getDefault().getJavaTextTools();
3449     return textTools.affectsBehavior(event);
3450   }
3451
3452   /**
3453    * Jumps to the error next according to the given direction.
3454    */
3455   public void gotoError(boolean forward) {
3456
3457     ISelectionProvider provider = getSelectionProvider();
3458
3459     ITextSelection s = (ITextSelection) provider.getSelection();
3460     Position errorPosition = new Position(0, 0);
3461     IJavaAnnotation nextError = getNextError(s.getOffset(), forward, errorPosition);
3462
3463     if (nextError != null) {
3464
3465       IMarker marker = null;
3466       if (nextError instanceof MarkerAnnotation)
3467         marker = ((MarkerAnnotation) nextError).getMarker();
3468       else {
3469         Iterator e = nextError.getOverlaidIterator();
3470         if (e != null) {
3471           while (e.hasNext()) {
3472             Object o = e.next();
3473             if (o instanceof MarkerAnnotation) {
3474               marker = ((MarkerAnnotation) o).getMarker();
3475               break;
3476             }
3477           }
3478         }
3479       }
3480
3481       if (marker != null) {
3482         IWorkbenchPage page = getSite().getPage();
3483         IViewPart view = view = page.findView("org.eclipse.ui.views.TaskList"); //$NON-NLS-1$
3484         if (view instanceof TaskList) {
3485           StructuredSelection ss = new StructuredSelection(marker);
3486           ((TaskList) view).setSelection(ss, true);
3487         }
3488       }
3489
3490       selectAndReveal(errorPosition.getOffset(), errorPosition.getLength());
3491       //      setStatusLineErrorMessage(nextError.getMessage());
3492
3493     } else {
3494
3495       setStatusLineErrorMessage(null);
3496
3497     }
3498   }
3499
3500   private IJavaAnnotation getNextError(int offset, boolean forward, Position errorPosition) {
3501
3502     IJavaAnnotation nextError = null;
3503     Position nextErrorPosition = null;
3504
3505     IDocument document = getDocumentProvider().getDocument(getEditorInput());
3506     int endOfDocument = document.getLength();
3507     int distance = 0;
3508
3509     IAnnotationModel model = getDocumentProvider().getAnnotationModel(getEditorInput());
3510     Iterator e = new JavaAnnotationIterator(model, false);
3511     while (e.hasNext()) {
3512
3513       IJavaAnnotation a = (IJavaAnnotation) e.next();
3514       if (a.hasOverlay() || !a.isProblem())
3515         continue;
3516
3517       Position p = model.getPosition((Annotation) a);
3518       if (!p.includes(offset)) {
3519
3520         int currentDistance = 0;
3521
3522         if (forward) {
3523           currentDistance = p.getOffset() - offset;
3524           if (currentDistance < 0)
3525             currentDistance = endOfDocument - offset + p.getOffset();
3526         } else {
3527           currentDistance = offset - p.getOffset();
3528           if (currentDistance < 0)
3529             currentDistance = offset + endOfDocument - p.getOffset();
3530         }
3531
3532         if (nextError == null || currentDistance < distance) {
3533           distance = currentDistance;
3534           nextError = a;
3535           nextErrorPosition = p;
3536         }
3537       }
3538     }
3539
3540     if (nextErrorPosition != null) {
3541       errorPosition.setOffset(nextErrorPosition.getOffset());
3542       errorPosition.setLength(nextErrorPosition.getLength());
3543     }
3544
3545     return nextError;
3546   }
3547
3548   void removeOccurrenceAnnotations() {
3549     IDocumentProvider documentProvider = getDocumentProvider();
3550     if (documentProvider == null)
3551       return;
3552
3553     IAnnotationModel annotationModel = documentProvider.getAnnotationModel(getEditorInput());
3554     if (annotationModel == null || fOccurrenceAnnotations == null)
3555       return;
3556
3557     synchronized (annotationModel) {
3558       if (annotationModel instanceof IAnnotationModelExtension) {
3559         ((IAnnotationModelExtension) annotationModel).replaceAnnotations(fOccurrenceAnnotations, null);
3560       } else {
3561         for (int i = 0, length = fOccurrenceAnnotations.length; i < length; i++)
3562           annotationModel.removeAnnotation(fOccurrenceAnnotations[i]);
3563       }
3564       fOccurrenceAnnotations = null;
3565     }
3566   }
3567
3568   //  protected void uninstallOverrideIndicator() {
3569   //    if (fOverrideIndicatorManager != null) {
3570   //            fOverrideIndicatorManager.removeAnnotations();
3571   //            fOverrideIndicatorManager= null;
3572   //    }
3573   //}
3574
3575   protected void installOverrideIndicator(boolean waitForReconcilation) {
3576     //  uninstallOverrideIndicator();
3577     IAnnotationModel model = getDocumentProvider().getAnnotationModel(getEditorInput());
3578     //  IJavaElement inputElement= getInputJavaElement();
3579
3580     //  if (model == null || inputElement == null)
3581     //          return;
3582
3583     //  CompilationUnit ast=
3584     // PHPeclipsePlugin.getDefault().getASTProvider().getAST(inputElement,
3585     // true, null);
3586     //  fOverrideIndicatorManager= new OverrideIndicatorManager(model,
3587     // inputElement, ast);
3588   }
3589
3590   /**
3591          * Tells whether override indicators are shown.
3592          *
3593          * @return <code>true</code> if the override indicators are shown
3594          * @since 3.0
3595          */
3596 //      protected boolean isShowingOverrideIndicators() {
3597 //              AnnotationPreference preference= getAnnotationPreferenceLookup().getAnnotationPreference(OverrideIndicatorManager.ANNOTATION_TYPE);
3598 //              IPreferenceStore store= getPreferenceStore();
3599 //              return getBoolean(store, preference.getHighlightPreferenceKey())
3600 //                      || getBoolean(store, preference.getVerticalRulerPreferenceKey())
3601 //                      || getBoolean(store, preference.getOverviewRulerPreferenceKey())
3602 //                      || getBoolean(store, preference.getTextPreferenceKey());
3603 //      }
3604   /**
3605    * Returns the boolean preference for the given key.
3606    *
3607    * @param store
3608    *          the preference store
3609    * @param key
3610    *          the preference key
3611    * @return <code>true</code> if the key exists in the store and its value is <code>true</code>
3612    * @since 3.0
3613    */
3614   private boolean getBoolean(IPreferenceStore store, String key) {
3615     return key != null && store.getBoolean(key);
3616   }
3617
3618   /**
3619    * Returns the folding action group, or <code>null</code> if there is none.
3620    *
3621    * @return the folding action group, or <code>null</code> if there is none
3622    * @since 3.0
3623    */
3624   protected FoldingActionGroup getFoldingActionGroup() {
3625     return fFoldingGroup;
3626   }
3627
3628   /**
3629    * React to changed selection.
3630    *
3631    * @since 3.0
3632    */
3633   protected void selectionChanged() {
3634     if (getSelectionProvider() == null)
3635       return;
3636     ISourceReference element = computeHighlightRangeSourceReference();
3637     if (getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SYNC_OUTLINE_ON_CURSOR_MOVE))
3638       synchronizeOutlinePage(element);
3639     setSelection(element, false);
3640     //          updateStatusLine();
3641   }
3642
3643   private boolean isJavaOutlinePageActive() {
3644     IWorkbenchPart part = getActivePart();
3645     return part instanceof ContentOutline && ((ContentOutline) part).getCurrentPage() == fOutlinePage;
3646   }
3647
3648   private IWorkbenchPart getActivePart() {
3649     IWorkbenchWindow window = getSite().getWorkbenchWindow();
3650     IPartService service = window.getPartService();
3651     IWorkbenchPart part = service.getActivePart();
3652     return part;
3653   }
3654
3655   /**
3656    * Computes and returns the source reference that includes the caret and serves as provider for the outline page selection and the
3657    * editor range indication.
3658    *
3659    * @return the computed source reference
3660    * @since 3.0
3661    */
3662   protected ISourceReference computeHighlightRangeSourceReference() {
3663     ISourceViewer sourceViewer = getSourceViewer();
3664     if (sourceViewer == null)
3665       return null;
3666
3667     StyledText styledText = sourceViewer.getTextWidget();
3668     if (styledText == null)
3669       return null;
3670
3671     int caret = 0;
3672     if (sourceViewer instanceof ITextViewerExtension5) {
3673       ITextViewerExtension5 extension = (ITextViewerExtension5) sourceViewer;
3674       caret = extension.widgetOffset2ModelOffset(styledText.getCaretOffset());
3675     } else {
3676       int offset = sourceViewer.getVisibleRegion().getOffset();
3677       caret = offset + styledText.getCaretOffset();
3678     }
3679
3680     IJavaElement element = getElementAt(caret, false);
3681
3682     if (!(element instanceof ISourceReference))
3683       return null;
3684
3685     if (element.getElementType() == IJavaElement.IMPORT_DECLARATION) {
3686
3687       IImportDeclaration declaration = (IImportDeclaration) element;
3688       IImportContainer container = (IImportContainer) declaration.getParent();
3689       ISourceRange srcRange = null;
3690
3691       try {
3692         srcRange = container.getSourceRange();
3693       } catch (JavaModelException e) {
3694       }
3695
3696       if (srcRange != null && srcRange.getOffset() == caret)
3697         return container;
3698     }
3699
3700     return (ISourceReference) element;
3701   }
3702
3703   /**
3704    * Returns the most narrow java element including the given offset.
3705    *
3706    * @param offset
3707    *          the offset inside of the requested element
3708    * @param reconcile
3709    *          <code>true</code> if editor input should be reconciled in advance
3710    * @return the most narrow java element
3711    * @since 3.0
3712    */
3713   protected IJavaElement getElementAt(int offset, boolean reconcile) {
3714     return getElementAt(offset);
3715   }
3716 }