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.Iterator;
  16 import java.util.List;
  17 import java.util.ResourceBundle;
  18 import java.util.StringTokenizer;
  19
  20 import net.sourceforge.phpdt.core.ICompilationUnit;
  21 import net.sourceforge.phpdt.core.IJavaElement;
  22 import net.sourceforge.phpdt.core.IMember;
  23 import net.sourceforge.phpdt.core.ISourceRange;
  24 import net.sourceforge.phpdt.core.ISourceReference;
  25 import net.sourceforge.phpdt.core.JavaModelException;
  26 import net.sourceforge.phpdt.internal.ui.actions.CompositeActionGroup;
  27 import net.sourceforge.phpdt.internal.ui.text.HTMLTextPresenter;
  28 import net.sourceforge.phpdt.internal.ui.text.PHPPairMatcher;
  29 import net.sourceforge.phpdt.internal.ui.viewsupport.IViewPartInputProvider;
  30 import net.sourceforge.phpdt.ui.IContextMenuConstants;
  31 import net.sourceforge.phpdt.ui.JavaUI;
  32 import net.sourceforge.phpdt.ui.PreferenceConstants;
  33 import net.sourceforge.phpdt.ui.actions.GenerateActionGroup;
  34 import net.sourceforge.phpdt.ui.actions.GotoMatchingBracketAction;
  35 import net.sourceforge.phpdt.ui.text.IColorManager;
  36 import net.sourceforge.phpdt.ui.text.JavaTextTools;
  37 import net.sourceforge.phpeclipse.PHPCore;
  38 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  39 import net.sourceforge.phpeclipse.phpeditor.php.IPHPPartitionScannerConstants;
  40
  41 import org.eclipse.core.resources.IMarker;
  42 import org.eclipse.core.resources.IResource;
  43 import org.eclipse.core.runtime.CoreException;
  44 import org.eclipse.core.runtime.IStatus;
  45 import org.eclipse.core.runtime.Preferences;
  46 import org.eclipse.jface.action.Action;
  47 import org.eclipse.jface.action.GroupMarker;
  48 import org.eclipse.jface.action.IAction;
  49 import org.eclipse.jface.action.MenuManager;
  50 import org.eclipse.jface.action.Separator;
  51 import org.eclipse.jface.preference.IPreferenceStore;
  52 import org.eclipse.jface.preference.PreferenceConverter;
  53 import org.eclipse.jface.text.BadLocationException;
  54 import org.eclipse.jface.text.DefaultInformationControl;
  55 import org.eclipse.jface.text.DocumentEvent;
  56 import org.eclipse.jface.text.IDocument;
  57 import org.eclipse.jface.text.IDocumentListener;
  58 import org.eclipse.jface.text.IInformationControl;
  59 import org.eclipse.jface.text.IInformationControlCreator;
  60 import org.eclipse.jface.text.IRegion;
  61 import org.eclipse.jface.text.ITextHover;
  62 import org.eclipse.jface.text.ITextInputListener;
  63 import org.eclipse.jface.text.ITextOperationTarget;
  64 import org.eclipse.jface.text.ITextSelection;
  65 import org.eclipse.jface.text.ITextViewer;
  66 import org.eclipse.jface.text.ITextViewerExtension2;
  67 import org.eclipse.jface.text.ITextViewerExtension3;
  68 import org.eclipse.jface.text.ITypedRegion;
  69 import org.eclipse.jface.text.Position;
  70 import org.eclipse.jface.text.Region;
  71 import org.eclipse.jface.text.TextSelection;
  72 import org.eclipse.jface.text.information.IInformationProvider;
  73 import org.eclipse.jface.text.information.InformationPresenter;
  74 import org.eclipse.jface.text.source.Annotation;
  75 import org.eclipse.jface.text.source.AnnotationRulerColumn;
  76 import org.eclipse.jface.text.source.CompositeRuler;
  77 import org.eclipse.jface.text.source.IAnnotationAccess;
  78 import org.eclipse.jface.text.source.IAnnotationModel;
  79 import org.eclipse.jface.text.source.IOverviewRuler;
  80 import org.eclipse.jface.text.source.ISharedTextColors;
  81 import org.eclipse.jface.text.source.ISourceViewer;
  82 import org.eclipse.jface.text.source.ISourceViewerExtension;
  83 import org.eclipse.jface.text.source.IVerticalRuler;
  84 import org.eclipse.jface.text.source.IVerticalRulerColumn;
  85 import org.eclipse.jface.text.source.LineNumberRulerColumn;
  86 import org.eclipse.jface.text.source.OverviewRuler;
  87 import org.eclipse.jface.text.source.SourceViewer;
  88 import org.eclipse.jface.text.source.SourceViewerConfiguration;
  89 import org.eclipse.jface.util.IPropertyChangeListener;
  90 import org.eclipse.jface.util.PropertyChangeEvent;
  91 import org.eclipse.jface.viewers.ISelection;
  92 import org.eclipse.jface.viewers.ISelectionChangedListener;
  93 import org.eclipse.jface.viewers.ISelectionProvider;
  94 import org.eclipse.jface.viewers.IStructuredSelection;
  95 import org.eclipse.jface.viewers.SelectionChangedEvent;
  96 import org.eclipse.jface.viewers.StructuredSelection;
  97 import org.eclipse.swt.SWT;
  98 import org.eclipse.swt.custom.BidiSegmentEvent;
  99 import org.eclipse.swt.custom.BidiSegmentListener;
 100 import org.eclipse.swt.custom.StyleRange;
 101 import org.eclipse.swt.custom.StyledText;
 102 import org.eclipse.swt.events.FocusEvent;
 103 import org.eclipse.swt.events.FocusListener;
 104 import org.eclipse.swt.events.KeyEvent;
 105 import org.eclipse.swt.events.KeyListener;
 106 import org.eclipse.swt.events.MouseEvent;
 107 import org.eclipse.swt.events.MouseListener;
 108 import org.eclipse.swt.events.MouseMoveListener;
 109 import org.eclipse.swt.events.PaintEvent;
 110 import org.eclipse.swt.events.PaintListener;
 111 import org.eclipse.swt.graphics.Color;
 112 import org.eclipse.swt.graphics.Cursor;
 113 import org.eclipse.swt.graphics.GC;
 114 import org.eclipse.swt.graphics.Image;
 115 import org.eclipse.swt.graphics.Point;
 116 import org.eclipse.swt.graphics.RGB;
 117 import org.eclipse.swt.widgets.Composite;
 118 import org.eclipse.swt.widgets.Control;
 119 import org.eclipse.swt.widgets.Display;
 120 import org.eclipse.swt.widgets.Shell;
 121 import org.eclipse.ui.IEditorInput;
 122 import org.eclipse.ui.IPageLayout;
 123 import org.eclipse.ui.IPartService;
 124 import org.eclipse.ui.IViewPart;
 125 import org.eclipse.ui.IWorkbenchPage;
 126 import org.eclipse.ui.IWorkbenchPart;
 127 import org.eclipse.ui.IWorkbenchWindow;
 128 import org.eclipse.ui.actions.ActionContext;
 129 import org.eclipse.ui.actions.ActionGroup;
 130 import org.eclipse.ui.editors.text.DefaultEncodingSupport;
 131 import org.eclipse.ui.editors.text.IEncodingSupport;
 132 import org.eclipse.ui.part.IShowInTargetList;
 133 import org.eclipse.ui.texteditor.AddTaskAction;
 134 import org.eclipse.ui.texteditor.ContentAssistAction;
 135 import org.eclipse.ui.texteditor.DefaultRangeIndicator;
 136 import org.eclipse.ui.texteditor.IAbstractTextEditorHelpContextIds;
 137 import org.eclipse.ui.texteditor.IDocumentProvider;
 138 import org.eclipse.ui.texteditor.IEditorStatusLine;
 139 import org.eclipse.ui.texteditor.ITextEditorActionConstants;
 140 import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
 141 import org.eclipse.ui.texteditor.MarkerAnnotation;
 142 import org.eclipse.ui.texteditor.ResourceAction;
 143 import org.eclipse.ui.texteditor.SourceViewerDecorationSupport;
 144 import org.eclipse.ui.texteditor.StatusTextEditor;
 145 import org.eclipse.ui.texteditor.TextEditorAction;
 146 import org.eclipse.ui.texteditor.TextOperationAction;
 147 import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
 148 import org.eclipse.ui.views.tasklist.TaskList;
 149
 150 /**
 151  * PHP specific text editor.
 152  */
 153 public abstract class PHPEditor extends StatusTextEditor implements IViewPartInputProvider { // extends TextEditor {
 154   /**
 155          * "Smart" runnable for updating the outline page's selection.
 156          */
 157   class OutlinePageSelectionUpdater implements Runnable {
 158
 159     /** Has the runnable already been posted? */
 160     private boolean fPosted = false;
 161
 162     public OutlinePageSelectionUpdater() {
 163     }
 164
 165     /*
 166      * @see Runnable#run()
 167      */
 168     public void run() {
 169       synchronizeOutlinePageSelection();
 170       fPosted = false;
 171     }
 172
 173     /**
 174      * Posts this runnable into the event queue.
 175      */
 176     public void post() {
 177       if (fPosted)
 178         return;
 179
 180       Shell shell = getSite().getShell();
 181       if (shell != null & !shell.isDisposed()) {
 182         fPosted = true;
 183         shell.getDisplay().asyncExec(this);
 184       }
 185     }
 186   };
 187   class SelectionChangedListener implements ISelectionChangedListener {
 188     public void selectionChanged(SelectionChangedEvent event) {
 189       doSelectionChanged(event);
 190     }
 191   };
 192
 193   /*
 194   * Link mode.
 195   */
 196   class MouseClickListener
 197     implements KeyListener, MouseListener, MouseMoveListener, FocusListener, PaintListener, IPropertyChangeListener, IDocumentListener, ITextInputListener {
 198
 199     /** The session is active. */
 200     private boolean fActive;
 201
 202     /** The currently active style range. */
 203     private IRegion fActiveRegion;
 204     /** The currently active style range as position. */
 205     private Position fRememberedPosition;
 206     /** The hand cursor. */
 207     private Cursor fCursor;
 208
 209     /** The link color. */
 210     private Color fColor;
 211     /** The key modifier mask. */
 212     private int fKeyModifierMask;
 213
 214     public void deactivate() {
 215       deactivate(false);
 216     }
 217
 218     public void deactivate(boolean redrawAll) {
 219       if (!fActive)
 220         return;
 221
 222       repairRepresentation(redrawAll);
 223       fActive = false;
 224     }
 225
 226     public void install() {
 227
 228       ISourceViewer sourceViewer = getSourceViewer();
 229       if (sourceViewer == null)
 230         return;
 231
 232       StyledText text = sourceViewer.getTextWidget();
 233       if (text == null || text.isDisposed())
 234         return;
 235
 236       updateColor(sourceViewer);
 237
 238       sourceViewer.addTextInputListener(this);
 239
 240       IDocument document = sourceViewer.getDocument();
 241       if (document != null)
 242         document.addDocumentListener(this);
 243
 244       text.addKeyListener(this);
 245       text.addMouseListener(this);
 246       text.addMouseMoveListener(this);
 247       text.addFocusListener(this);
 248       text.addPaintListener(this);
 249
 250       updateKeyModifierMask();
 251
 252       IPreferenceStore preferenceStore = getPreferenceStore();
 253       preferenceStore.addPropertyChangeListener(this);
 254     }
 255
 256     private void updateKeyModifierMask() {
 257       String modifiers = getPreferenceStore().getString(BROWSER_LIKE_LINKS_KEY_MODIFIER);
 258       fKeyModifierMask = computeStateMask(modifiers);
 259       if (fKeyModifierMask == -1) {
 260         // Fallback to stored state mask
 261         fKeyModifierMask = getPreferenceStore().getInt(BROWSER_LIKE_LINKS_KEY_MODIFIER_MASK);
 262       };
 263     }
 264
 265     private int computeStateMask(String modifiers) {
 266       if (modifiers == null)
 267         return -1;
 268
 269       if (modifiers.length() == 0)
 270         return SWT.NONE;
 271
 272       int stateMask = 0;
 273       StringTokenizer modifierTokenizer = new StringTokenizer(modifiers, ",;.:+-* "); //$NON-NLS-1$
 274       while (modifierTokenizer.hasMoreTokens()) {
 275         int modifier = EditorUtility.findLocalizedModifier(modifierTokenizer.nextToken());
 276         if (modifier == 0 || (stateMask & modifier) == modifier)
 277           return -1;
 278         stateMask = stateMask | modifier;
 279       }
 280       return stateMask;
 281     }
 282
 283     public void uninstall() {
 284
 285       if (fColor != null) {
 286         fColor.dispose();
 287         fColor = null;
 288       }
 289
 290       if (fCursor != null) {
 291         fCursor.dispose();
 292         fCursor = null;
 293       }
 294
 295       ISourceViewer sourceViewer = getSourceViewer();
 296       if (sourceViewer == null)
 297         return;
 298
 299       sourceViewer.removeTextInputListener(this);
 300
 301       IDocument document = sourceViewer.getDocument();
 302       if (document != null)
 303         document.removeDocumentListener(this);
 304
 305       IPreferenceStore preferenceStore = getPreferenceStore();
 306       if (preferenceStore != null)
 307         preferenceStore.removePropertyChangeListener(this);
 308
 309       StyledText text = sourceViewer.getTextWidget();
 310       if (text == null || text.isDisposed())
 311         return;
 312
 313       text.removeKeyListener(this);
 314       text.removeMouseListener(this);
 315       text.removeMouseMoveListener(this);
 316       text.removeFocusListener(this);
 317       text.removePaintListener(this);
 318     }
 319
 320     /*
 321      * @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)
 322      */
 323     public void propertyChange(PropertyChangeEvent event) {
 324       if (event.getProperty().equals(PHPEditor.LINK_COLOR)) {
 325         ISourceViewer viewer = getSourceViewer();
 326         if (viewer != null)
 327           updateColor(viewer);
 328       } else if (event.getProperty().equals(BROWSER_LIKE_LINKS_KEY_MODIFIER)) {
 329         updateKeyModifierMask();
 330       }
 331     }
 332
 333     private void updateColor(ISourceViewer viewer) {
 334       if (fColor != null)
 335         fColor.dispose();
 336
 337       StyledText text = viewer.getTextWidget();
 338       if (text == null || text.isDisposed())
 339         return;
 340
 341       Display display = text.getDisplay();
 342       fColor = createColor(getPreferenceStore(), PHPEditor.LINK_COLOR, display);
 343     }
 344
 345     /**
 346      * Creates a color from the information stored in the given preference store.
 347      * Returns <code>null</code> if there is no such information available.
 348      */
 349     private Color createColor(IPreferenceStore store, String key, Display display) {
 350
 351       RGB rgb = null;
 352
 353       if (store.contains(key)) {
 354
 355         if (store.isDefault(key))
 356           rgb = PreferenceConverter.getDefaultColor(store, key);
 357         else
 358           rgb = PreferenceConverter.getColor(store, key);
 359
 360         if (rgb != null)
 361           return new Color(display, rgb);
 362       }
 363
 364       return null;
 365     }
 366
 367     private void repairRepresentation() {
 368       repairRepresentation(false);
 369     }
 370
 371     private void repairRepresentation(boolean redrawAll) {
 372
 373       if (fActiveRegion == null)
 374         return;
 375
 376       ISourceViewer viewer = getSourceViewer();
 377       if (viewer != null) {
 378         resetCursor(viewer);
 379
 380         int offset = fActiveRegion.getOffset();
 381         int length = fActiveRegion.getLength();
 382
 383         // remove style
 384         if (!redrawAll && viewer instanceof ITextViewerExtension2)
 385            ((ITextViewerExtension2) viewer).invalidateTextPresentation(offset, length);
 386         else
 387           viewer.invalidateTextPresentation();
 388
 389         // remove underline
 390         if (viewer instanceof ITextViewerExtension3) {
 391           ITextViewerExtension3 extension = (ITextViewerExtension3) viewer;
 392           offset = extension.modelOffset2WidgetOffset(offset);
 393         } else {
 394           offset -= viewer.getVisibleRegion().getOffset();
 395         }
 396
 397         StyledText text = viewer.getTextWidget();
 398         try {
 399           text.redrawRange(offset, length, true);
 400         } catch (IllegalArgumentException x) {
 401           PHPeclipsePlugin.log(x);
 402         }
 403       }
 404
 405       fActiveRegion = null;
 406     }
 407
 408     // will eventually be replaced by a method provided by jdt.core
 409     private IRegion selectWord(IDocument document, int anchor) {
 410
 411       try {
 412         int offset = anchor;
 413         char c;
 414
 415         while (offset >= 0) {
 416           c = document.getChar(offset);
 417           if (!Character.isJavaIdentifierPart(c))
 418             break;
 419           --offset;
 420         }
 421
 422         int start = offset;
 423
 424         offset = anchor;
 425         int length = document.getLength();
 426
 427         while (offset < length) {
 428           c = document.getChar(offset);
 429           if (!Character.isJavaIdentifierPart(c))
 430             break;
 431           ++offset;
 432         }
 433
 434         int end = offset;
 435
 436         if (start == end)
 437           return new Region(start, 0);
 438         else
 439           return new Region(start + 1, end - start - 1);
 440
 441       } catch (BadLocationException x) {
 442         return null;
 443       }
 444     }
 445
 446     IRegion getCurrentTextRegion(ISourceViewer viewer) {
 447
 448       int offset = getCurrentTextOffset(viewer);
 449       if (offset == -1)
 450         return null;
 451
 452       return null;
 453       //                                IJavaElement input= SelectionConverter.getInput(PHPEditor.this);
 454       //                                if (input == null)
 455       //                                        return null;
 456       //
 457       //                                try {
 458       //
 459       //                                        IJavaElement[] elements= null;
 460       //                                        synchronized (input) {
 461       //                                                elements= ((ICodeAssist) input).codeSelect(offset, 0);
 462       //                                        }
 463       //
 464       //                                        if (elements == null || elements.length == 0)
 465       //                                                return null;
 466       //
 467       //                                        return selectWord(viewer.getDocument(), offset);
 468       //
 469       //                                } catch (JavaModelException e) {
 470       //                                        return null;
 471       //                                }
 472     }
 473
 474     private int getCurrentTextOffset(ISourceViewer viewer) {
 475
 476       try {
 477         StyledText text = viewer.getTextWidget();
 478         if (text == null || text.isDisposed())
 479           return -1;
 480
 481         Display display = text.getDisplay();
 482         Point absolutePosition = display.getCursorLocation();
 483         Point relativePosition = text.toControl(absolutePosition);
 484
 485         int widgetOffset = text.getOffsetAtLocation(relativePosition);
 486         if (viewer instanceof ITextViewerExtension3) {
 487           ITextViewerExtension3 extension = (ITextViewerExtension3) viewer;
 488           return extension.widgetOffset2ModelOffset(widgetOffset);
 489         } else {
 490           return widgetOffset + viewer.getVisibleRegion().getOffset();
 491         }
 492
 493       } catch (IllegalArgumentException e) {
 494         return -1;
 495       }
 496     }
 497
 498     private void highlightRegion(ISourceViewer viewer, IRegion region) {
 499
 500       if (region.equals(fActiveRegion))
 501         return;
 502
 503       repairRepresentation();
 504
 505       StyledText text = viewer.getTextWidget();
 506       if (text == null || text.isDisposed())
 507         return;
 508
 509       // highlight region
 510       int offset = 0;
 511       int length = 0;
 512
 513       if (viewer instanceof ITextViewerExtension3) {
 514         ITextViewerExtension3 extension = (ITextViewerExtension3) viewer;
 515         IRegion widgetRange = extension.modelRange2WidgetRange(region);
 516         if (widgetRange == null)
 517           return;
 518
 519         offset = widgetRange.getOffset();
 520         length = widgetRange.getLength();
 521
 522       } else {
 523         offset = region.getOffset() - viewer.getVisibleRegion().getOffset();
 524         length = region.getLength();
 525       }
 526
 527       StyleRange oldStyleRange = text.getStyleRangeAtOffset(offset);
 528       Color foregroundColor = fColor;
 529       Color backgroundColor = oldStyleRange == null ? text.getBackground() : oldStyleRange.background;
 530       StyleRange styleRange = new StyleRange(offset, length, foregroundColor, backgroundColor);
 531       text.setStyleRange(styleRange);
 532
 533       // underline
 534       text.redrawRange(offset, length, true);
 535
 536       fActiveRegion = region;
 537     }
 538
 539     private void activateCursor(ISourceViewer viewer) {
 540       StyledText text = viewer.getTextWidget();
 541       if (text == null || text.isDisposed())
 542         return;
 543       Display display = text.getDisplay();
 544       if (fCursor == null)
 545         fCursor = new Cursor(display, SWT.CURSOR_HAND);
 546       text.setCursor(fCursor);
 547     }
 548
 549     private void resetCursor(ISourceViewer viewer) {
 550       StyledText text = viewer.getTextWidget();
 551       if (text != null && !text.isDisposed())
 552         text.setCursor(null);
 553
 554       if (fCursor != null) {
 555         fCursor.dispose();
 556         fCursor = null;
 557       }
 558     }
 559
 560     /*
 561      * @see org.eclipse.swt.events.KeyListener#keyPressed(org.eclipse.swt.events.KeyEvent)
 562      */
 563     public void keyPressed(KeyEvent event) {
 564
 565       if (fActive) {
 566         deactivate();
 567         return;
 568       }
 569
 570       if (event.keyCode != fKeyModifierMask) {
 571         deactivate();
 572         return;
 573       }
 574
 575       fActive = true;
 576
 577       //                                removed for #25871
 578       //
 579       //                                ISourceViewer viewer= getSourceViewer();
 580       //                                if (viewer == null)
 581       //                                        return;
 582       //
 583       //                                IRegion region= getCurrentTextRegion(viewer);
 584       //                                if (region == null)
 585       //                                        return;
 586       //
 587       //                                highlightRegion(viewer, region);
 588       //                                activateCursor(viewer);
 589     }
 590
 591     /*
 592      * @see org.eclipse.swt.events.KeyListener#keyReleased(org.eclipse.swt.events.KeyEvent)
 593      */
 594     public void keyReleased(KeyEvent event) {
 595
 596       if (!fActive)
 597         return;
 598
 599       deactivate();
 600     }
 601
 602     /*
 603      * @see org.eclipse.swt.events.MouseListener#mouseDoubleClick(org.eclipse.swt.events.MouseEvent)
 604      */
 605     public void mouseDoubleClick(MouseEvent e) {
 606     }
 607     /*
 608      * @see org.eclipse.swt.events.MouseListener#mouseDown(org.eclipse.swt.events.MouseEvent)
 609      */
 610     public void mouseDown(MouseEvent event) {
 611
 612       if (!fActive)
 613         return;
 614
 615       if (event.stateMask != fKeyModifierMask) {
 616         deactivate();
 617         return;
 618       }
 619
 620       if (event.button != 1) {
 621         deactivate();
 622         return;
 623       }
 624     }
 625
 626     /*
 627      * @see org.eclipse.swt.events.MouseListener#mouseUp(org.eclipse.swt.events.MouseEvent)
 628      */
 629     public void mouseUp(MouseEvent e) {
 630
 631       if (!fActive)
 632         return;
 633
 634       if (e.button != 1) {
 635         deactivate();
 636         return;
 637       }
 638
 639       boolean wasActive = fCursor != null;
 640
 641       deactivate();
 642
 643       if (wasActive) {
 644         IAction action = getAction("OpenEditor"); //$NON-NLS-1$
 645         if (action != null)
 646           action.run();
 647       }
 648     }
 649
 650     /*
 651      * @see org.eclipse.swt.events.MouseMoveListener#mouseMove(org.eclipse.swt.events.MouseEvent)
 652      */
 653     public void mouseMove(MouseEvent event) {
 654
 655       if (event.widget instanceof Control && !((Control) event.widget).isFocusControl()) {
 656         deactivate();
 657         return;
 658       }
 659
 660       if (!fActive) {
 661         if (event.stateMask != fKeyModifierMask)
 662           return;
 663         // modifier was already pressed
 664         fActive = true;
 665       }
 666
 667       ISourceViewer viewer = getSourceViewer();
 668       if (viewer == null) {
 669         deactivate();
 670         return;
 671       }
 672
 673       StyledText text = viewer.getTextWidget();
 674       if (text == null || text.isDisposed()) {
 675         deactivate();
 676         return;
 677       }
 678
 679       if ((event.stateMask & SWT.BUTTON1) != 0 && text.getSelectionCount() != 0) {
 680         deactivate();
 681         return;
 682       }
 683
 684       IRegion region = getCurrentTextRegion(viewer);
 685       if (region == null || region.getLength() == 0) {
 686         repairRepresentation();
 687         return;
 688       }
 689
 690       highlightRegion(viewer, region);
 691       activateCursor(viewer);
 692     }
 693
 694     /*
 695      * @see org.eclipse.swt.events.FocusListener#focusGained(org.eclipse.swt.events.FocusEvent)
 696      */
 697     public void focusGained(FocusEvent e) {
 698     }
 699
 700     /*
 701      * @see org.eclipse.swt.events.FocusListener#focusLost(org.eclipse.swt.events.FocusEvent)
 702      */
 703     public void focusLost(FocusEvent event) {
 704       deactivate();
 705     }
 706
 707     /*
 708      * @see org.eclipse.jface.text.IDocumentListener#documentAboutToBeChanged(org.eclipse.jface.text.DocumentEvent)
 709      */
 710     public void documentAboutToBeChanged(DocumentEvent event) {
 711       if (fActive && fActiveRegion != null) {
 712         fRememberedPosition = new Position(fActiveRegion.getOffset(), fActiveRegion.getLength());
 713         try {
 714           event.getDocument().addPosition(fRememberedPosition);
 715         } catch (BadLocationException x) {
 716           fRememberedPosition = null;
 717         }
 718       }
 719     }
 720
 721     /*
 722      * @see org.eclipse.jface.text.IDocumentListener#documentChanged(org.eclipse.jface.text.DocumentEvent)
 723      */
 724     public void documentChanged(DocumentEvent event) {
 725       if (fRememberedPosition != null && !fRememberedPosition.isDeleted()) {
 726         event.getDocument().removePosition(fRememberedPosition);
 727         fActiveRegion = new Region(fRememberedPosition.getOffset(), fRememberedPosition.getLength());
 728       }
 729       fRememberedPosition = null;
 730
 731       ISourceViewer viewer = getSourceViewer();
 732       if (viewer != null) {
 733         StyledText widget = viewer.getTextWidget();
 734         if (widget != null && !widget.isDisposed()) {
 735           widget.getDisplay().asyncExec(new Runnable() {
 736             public void run() {
 737               deactivate();
 738             }
 739           });
 740         }
 741       }
 742     }
 743
 744     /*
 745      * @see org.eclipse.jface.text.ITextInputListener#inputDocumentAboutToBeChanged(org.eclipse.jface.text.IDocument, org.eclipse.jface.text.IDocument)
 746      */
 747     public void inputDocumentAboutToBeChanged(IDocument oldInput, IDocument newInput) {
 748       if (oldInput == null)
 749         return;
 750       deactivate();
 751       oldInput.removeDocumentListener(this);
 752     }
 753
 754     /*
 755      * @see org.eclipse.jface.text.ITextInputListener#inputDocumentChanged(org.eclipse.jface.text.IDocument, org.eclipse.jface.text.IDocument)
 756      */
 757     public void inputDocumentChanged(IDocument oldInput, IDocument newInput) {
 758       if (newInput == null)
 759         return;
 760       newInput.addDocumentListener(this);
 761     }
 762
 763     /*
 764      * @see PaintListener#paintControl(PaintEvent)
 765      */
 766     public void paintControl(PaintEvent event) {
 767       if (fActiveRegion == null)
 768         return;
 769
 770       ISourceViewer viewer = getSourceViewer();
 771       if (viewer == null)
 772         return;
 773
 774       StyledText text = viewer.getTextWidget();
 775       if (text == null || text.isDisposed())
 776         return;
 777
 778       int offset = 0;
 779       int length = 0;
 780
 781       if (viewer instanceof ITextViewerExtension3) {
 782
 783         ITextViewerExtension3 extension = (ITextViewerExtension3) viewer;
 784         IRegion widgetRange = extension.modelRange2WidgetRange(new Region(offset, length));
 785         if (widgetRange == null)
 786           return;
 787
 788         offset = widgetRange.getOffset();
 789         length = widgetRange.getLength();
 790
 791       } else {
 792
 793         IRegion region = viewer.getVisibleRegion();
 794         if (!includes(region, fActiveRegion))
 795           return;
 796
 797         offset = fActiveRegion.getOffset() - region.getOffset();
 798         length = fActiveRegion.getLength();
 799       }
 800
 801       // support for bidi
 802       Point minLocation = getMinimumLocation(text, offset, length);
 803       Point maxLocation = getMaximumLocation(text, offset, length);
 804
 805       int x1 = minLocation.x;
 806       int x2 = minLocation.x + maxLocation.x - minLocation.x - 1;
 807       int y = minLocation.y + text.getLineHeight() - 1;
 808
 809       GC gc = event.gc;
 810       if (fColor != null && !fColor.isDisposed())
 811         gc.setForeground(fColor);
 812       gc.drawLine(x1, y, x2, y);
 813     }
 814
 815     private boolean includes(IRegion region, IRegion position) {
 816       return position.getOffset() >= region.getOffset() && position.getOffset() + position.getLength() <= region.getOffset() + region.getLength();
 817     }
 818
 819     private Point getMinimumLocation(StyledText text, int offset, int length) {
 820       Point minLocation = new Point(Integer.MAX_VALUE, Integer.MAX_VALUE);
 821
 822       for (int i = 0; i <= length; i++) {
 823         Point location = text.getLocationAtOffset(offset + i);
 824
 825         if (location.x < minLocation.x)
 826           minLocation.x = location.x;
 827         if (location.y < minLocation.y)
 828           minLocation.y = location.y;
 829       }
 830
 831       return minLocation;
 832     }
 833
 834     private Point getMaximumLocation(StyledText text, int offset, int length) {
 835       Point maxLocation = new Point(Integer.MIN_VALUE, Integer.MIN_VALUE);
 836
 837       for (int i = 0; i <= length; i++) {
 838         Point location = text.getLocationAtOffset(offset + i);
 839
 840         if (location.x > maxLocation.x)
 841           maxLocation.x = location.x;
 842         if (location.y > maxLocation.y)
 843           maxLocation.y = location.y;
 844       }
 845
 846       return maxLocation;
 847     }
 848   };
 849
 850   /**
 851    * This action dispatches into two behaviours: If there is no current text
 852    * hover, the javadoc is displayed using information presenter. If there is
 853    * a current text hover, it is converted into a information presenter in
 854    * order to make it sticky.
 855    */
 856   class InformationDispatchAction extends TextEditorAction {
 857
 858     /** The wrapped text operation action. */
 859     private final TextOperationAction fTextOperationAction;
 860
 861     /**
 862      * Creates a dispatch action.
 863      */
 864     public InformationDispatchAction(ResourceBundle resourceBundle, String prefix, final TextOperationAction textOperationAction) {
 865       super(resourceBundle, prefix, PHPEditor.this);
 866       if (textOperationAction == null)
 867         throw new IllegalArgumentException();
 868       fTextOperationAction = textOperationAction;
 869     }
 870
 871     /*
 872      * @see org.eclipse.jface.action.IAction#run()
 873      */
 874     public void run() {
 875
 876       ISourceViewer sourceViewer = getSourceViewer();
 877       if (sourceViewer == null) {
 878         fTextOperationAction.run();
 879         return;
 880       }
 881
 882       if (!(sourceViewer instanceof ITextViewerExtension2)) {
 883         fTextOperationAction.run();
 884         return;
 885       }
 886
 887       ITextViewerExtension2 textViewerExtension2 = (ITextViewerExtension2) sourceViewer;
 888
 889       // does a text hover exist?
 890       ITextHover textHover = textViewerExtension2.getCurrentTextHover();
 891       if (textHover == null) {
 892         fTextOperationAction.run();
 893         return;
 894       }
 895
 896       Point hoverEventLocation = textViewerExtension2.getHoverEventLocation();
 897       int offset = computeOffsetAtLocation(sourceViewer, hoverEventLocation.x, hoverEventLocation.y);
 898       if (offset == -1) {
 899         fTextOperationAction.run();
 900         return;
 901       }
 902
 903       try {
 904         // get the text hover content
 905         IDocument document = sourceViewer.getDocument();
 906         String contentType = document.getContentType(offset);
 907
 908         final IRegion hoverRegion = textHover.getHoverRegion(sourceViewer, offset);
 909         if (hoverRegion == null)
 910           return;
 911
 912         final String hoverInfo = textHover.getHoverInfo(sourceViewer, hoverRegion);
 913
 914         // with information provider
 915         IInformationProvider informationProvider = new IInformationProvider() {
 916           /*
 917            * @see org.eclipse.jface.text.information.IInformationProvider#getSubject(org.eclipse.jface.text.ITextViewer, int)
 918            */
 919           public IRegion getSubject(ITextViewer textViewer, int offset) {
 920             return hoverRegion;
 921           }
 922           /*
 923            * @see org.eclipse.jface.text.information.IInformationProvider#getInformation(org.eclipse.jface.text.ITextViewer, org.eclipse.jface.text.IRegion)
 924            */
 925           public String getInformation(ITextViewer textViewer, IRegion subject) {
 926             return hoverInfo;
 927           }
 928         };
 929
 930         fInformationPresenter.setOffset(offset);
 931         fInformationPresenter.setInformationProvider(informationProvider, contentType);
 932         fInformationPresenter.showInformation();
 933
 934       } catch (BadLocationException e) {
 935       }
 936     }
 937
 938     // modified version from TextViewer
 939     private int computeOffsetAtLocation(ITextViewer textViewer, int x, int y) {
 940
 941       StyledText styledText = textViewer.getTextWidget();
 942       IDocument document = textViewer.getDocument();
 943
 944       if (document == null)
 945         return -1;
 946
 947       try {
 948         int widgetLocation = styledText.getOffsetAtLocation(new Point(x, y));
 949         if (textViewer instanceof ITextViewerExtension3) {
 950           ITextViewerExtension3 extension = (ITextViewerExtension3) textViewer;
 951           return extension.widgetOffset2ModelOffset(widgetLocation);
 952         } else {
 953           IRegion visibleRegion = textViewer.getVisibleRegion();
 954           return widgetLocation + visibleRegion.getOffset();
 955         }
 956       } catch (IllegalArgumentException e) {
 957         return -1;
 958       }
 959
 960     }
 961   };
 962
 963   static protected class AnnotationAccess implements IAnnotationAccess {
 964     /*
 965      * @see org.eclipse.jface.text.source.IAnnotationAccess#getType(org.eclipse.jface.text.source.Annotation)
 966      */
 967     public Object getType(Annotation annotation) {
 968       if (annotation instanceof IJavaAnnotation) {
 969         IJavaAnnotation javaAnnotation = (IJavaAnnotation) annotation;
 970         if (javaAnnotation.isRelevant())
 971           return javaAnnotation.getAnnotationType();
 972       }
 973       return null;
 974     }
 975
 976     /*
 977      * @see org.eclipse.jface.text.source.IAnnotationAccess#isMultiLine(org.eclipse.jface.text.source.Annotation)
 978      */
 979     public boolean isMultiLine(Annotation annotation) {
 980       return true;
 981     }
 982
 983     /*
 984      * @see org.eclipse.jface.text.source.IAnnotationAccess#isTemporary(org.eclipse.jface.text.source.Annotation)
 985      */
 986     public boolean isTemporary(Annotation annotation) {
 987       if (annotation instanceof IJavaAnnotation) {
 988         IJavaAnnotation javaAnnotation = (IJavaAnnotation) annotation;
 989         if (javaAnnotation.isRelevant())
 990           return javaAnnotation.isTemporary();
 991       }
 992       return false;
 993     }
 994   };
 995
 996   private class PropertyChangeListener implements org.eclipse.core.runtime.Preferences.IPropertyChangeListener {
 997     /*
 998      * @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)
 999      */
1000     public void propertyChange(org.eclipse.core.runtime.Preferences.PropertyChangeEvent event) {
1001       handlePreferencePropertyChanged(event);
1002     }
1003   };
1004   /** Preference key for showing the line number ruler */
1005   private final static String LINE_NUMBER_RULER = PreferenceConstants.EDITOR_LINE_NUMBER_RULER;
1006   /** Preference key for the foreground color of the line numbers */
1007   private final static String LINE_NUMBER_COLOR = PreferenceConstants.EDITOR_LINE_NUMBER_RULER_COLOR;
1008   /** Preference key for the link color */
1009   private final static String LINK_COLOR = PreferenceConstants.EDITOR_LINK_COLOR;
1010   /** Preference key for compiler task tags */
1011   private final static String COMPILER_TASK_TAGS = PHPCore.COMPILER_TASK_TAGS;
1012
1013   // protected PHPActionGroup fActionGroups;
1014   //  /** The outline page */
1015   //  private AbstractContentOutlinePage fOutlinePage;
1016   /** The outline page */
1017   protected JavaOutlinePage fOutlinePage;
1018   /** Outliner context menu Id */
1019   protected String fOutlinerContextMenuId;
1020   /** Indicates whether this editor should react on outline page selection changes */
1021   private int fIgnoreOutlinePageSelection;
1022
1023         /** The outline page selection updater */
1024         private OutlinePageSelectionUpdater fUpdater;
1025   //  protected PHPSyntaxParserThread fValidationThread = null;
1026
1027   // private IPreferenceStore fPHPPrefStore;
1028   /** The selection changed listener */
1029   protected ISelectionChangedListener fSelectionChangedListener = new SelectionChangedListener();
1030
1031   /** The editor's bracket matcher */
1032   private PHPPairMatcher fBracketMatcher = new PHPPairMatcher(BRACKETS);
1033
1034
1035   /** The line number ruler column */
1036   private LineNumberRulerColumn fLineNumberRulerColumn;
1037   /** This editor's encoding support */
1038   private DefaultEncodingSupport fEncodingSupport;
1039   /** The mouse listener */
1040   private MouseClickListener fMouseListener;
1041
1042   protected CompositeActionGroup fActionGroups;
1043   /** The standard action groups added to the menu */
1044   protected GenerateActionGroup fGenerateActionGroup;
1045   protected CompositeActionGroup fContextMenuGroup;
1046
1047   /** The information presenter. */
1048   private InformationPresenter fInformationPresenter;
1049   /** The annotation access */
1050   protected IAnnotationAccess fAnnotationAccess = new AnnotationAccess();
1051   /** The overview ruler */
1052   protected OverviewRuler isOverviewRulerVisible;
1053   /** The source viewer decoration support */
1054   protected SourceViewerDecorationSupport fSourceViewerDecorationSupport;
1055   /** The overview ruler */
1056   protected OverviewRuler fOverviewRuler;
1057
1058   /** The preference property change listener for java core. */
1059   private org.eclipse.core.runtime.Preferences.IPropertyChangeListener fPropertyChangeListener = new PropertyChangeListener();
1060   /**
1061    * Returns the most narrow java element including the given offset
1062    *
1063    * @param offset the offset inside of the requested element
1064    */
1065   abstract protected IJavaElement getElementAt(int offset);
1066
1067   /**
1068    * Returns the java element of this editor's input corresponding to the given IJavaElement
1069    */
1070   abstract protected IJavaElement getCorrespondingElement(IJavaElement element);
1071   /**
1072          * Sets the input of the editor's outline page.
1073          */
1074   abstract protected void setOutlinePageInput(JavaOutlinePage page, IEditorInput input);
1075
1076   /**
1077    * Default constructor.
1078    */
1079   public PHPEditor() {
1080     super();
1081     JavaTextTools textTools = PHPeclipsePlugin.getDefault().getJavaTextTools();
1082     setSourceViewerConfiguration(new PHPSourceViewerConfiguration(textTools, this));
1083     setRangeIndicator(new DefaultRangeIndicator());
1084     setPreferenceStore(PHPeclipsePlugin.getDefault().getPreferenceStore());
1085
1086     // don't activate this scope without synchronizing plugin.xml !!!
1087     //    setKeyBindingScopes(new String[] { "net.sourceforge.phpdt.ui.phpEditorScope" }); //$NON-NLS-1$
1088
1089         if (PreferenceConstants.getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SYNC_OUTLINE_ON_CURSOR_MOVE))
1090           fUpdater= new OutlinePageSelectionUpdater();
1091   }
1092   //
1093   //    /**
1094   //     * @see IMember#getCompilationUnit()
1095   //     */
1096   //    public ICompilationUnit getCompilationUnit() {
1097   //            return this;
1098   //    }
1099   //    /**
1100   //     * @see org.phpeclipse.phpdt.internal.compiler.env.ICompilationUnit#getContents()
1101   //     */
1102   //    public char[] getContents() {
1103   //            IDocument doc = this.getDocumentProvider().getDocument(this.getEditorInput());
1104   //
1105   //            return doc.get().toCharArray();
1106   //    }
1107   /*
1108    * @see org.eclipse.ui.texteditor.AbstractTextEditor#updatePropertyDependentActions()
1109    */
1110   protected void updatePropertyDependentActions() {
1111     super.updatePropertyDependentActions();
1112     if (fEncodingSupport != null)
1113       fEncodingSupport.reset();
1114   }
1115
1116   /*
1117    * Update the hovering behavior depending on the preferences.
1118    */
1119   private void updateHoverBehavior() {
1120     SourceViewerConfiguration configuration = getSourceViewerConfiguration();
1121     String[] types = configuration.getConfiguredContentTypes(getSourceViewer());
1122
1123     for (int i = 0; i < types.length; i++) {
1124
1125       String t = types[i];
1126
1127       int[] stateMasks = configuration.getConfiguredTextHoverStateMasks(getSourceViewer(), t);
1128
1129       ISourceViewer sourceViewer = getSourceViewer();
1130       if (sourceViewer instanceof ITextViewerExtension2) {
1131         if (stateMasks != null) {
1132           for (int j = 0; j < stateMasks.length; j++) {
1133             int stateMask = stateMasks[j];
1134             ITextHover textHover = configuration.getTextHover(sourceViewer, t, stateMask);
1135             ((ITextViewerExtension2) sourceViewer).setTextHover(textHover, t, stateMask);
1136           }
1137         } else {
1138           ITextHover textHover = configuration.getTextHover(sourceViewer, t);
1139           ((ITextViewerExtension2) sourceViewer).setTextHover(textHover, t, ITextViewerExtension2.DEFAULT_HOVER_STATE_MASK);
1140         }
1141       } else
1142         sourceViewer.setTextHover(configuration.getTextHover(sourceViewer, t), t);
1143     }
1144   }
1145
1146   public void updatedTitleImage(Image image) {
1147     setTitleImage(image);
1148   }
1149   /*
1150    * @see net.sourceforge.phpdt.internal.ui.viewsupport.IViewPartInputProvider#getViewPartInput()
1151    */
1152   public Object getViewPartInput() {
1153     return getEditorInput().getAdapter(IResource.class);
1154   }
1155   /*
1156    * @see org.eclipse.ui.texteditor.AbstractTextEditor#doSetSelection(ISelection)
1157    */
1158   protected void doSetSelection(ISelection selection) {
1159     super.doSetSelection(selection);
1160     synchronizeOutlinePageSelection();
1161   }
1162   /*
1163    * @see org.eclipse.ui.IWorkbenchPart#createPartControl(org.eclipse.swt.
1164    * widgets.Composite)
1165    */
1166   public void createPartControl(Composite parent) {
1167     super.createPartControl(parent);
1168
1169     fSourceViewerDecorationSupport.install(getPreferenceStore());
1170
1171     Preferences preferences = PHPeclipsePlugin.getDefault().getPluginPreferences();
1172     preferences.addPropertyChangeListener(fPropertyChangeListener);
1173
1174     IInformationControlCreator informationControlCreator = new IInformationControlCreator() {
1175       public IInformationControl createInformationControl(Shell parent) {
1176         boolean cutDown = false;
1177         int style = cutDown ? SWT.NONE : (SWT.V_SCROLL | SWT.H_SCROLL);
1178         return new DefaultInformationControl(parent, SWT.RESIZE, style, new HTMLTextPresenter(cutDown));
1179       }
1180     };
1181
1182     fInformationPresenter = new InformationPresenter(informationControlCreator);
1183     fInformationPresenter.setSizeConstraints(60, 10, true, true);
1184     fInformationPresenter.install(getSourceViewer());
1185
1186   }
1187
1188   /**
1189    * Returns this document's complete text.
1190    *
1191    * @return the document's complete text
1192    */
1193   public String get() {
1194     IDocument doc = this.getDocumentProvider().getDocument(this.getEditorInput());
1195     return doc.get();
1196   }
1197
1198   /**
1199          * Sets the outliner's context menu ID.
1200          */
1201   protected void setOutlinerContextMenuId(String menuId) {
1202     fOutlinerContextMenuId = menuId;
1203   }
1204
1205   /**
1206    *  Returns the standard action group of this editor.
1207    */
1208   protected ActionGroup getActionGroup() {
1209     return fActionGroups;
1210   }
1211
1212   //  public JavaOutlinePage getfOutlinePage() {
1213   //    return fOutlinePage;
1214   //  }
1215
1216   /** The <code>PHPEditor</code> implementation of this
1217    * <code>AbstractTextEditor</code> method extend the
1218    * actions to add those specific to the receiver
1219    */
1220   protected void createActions() {
1221     super.createActions();
1222
1223     ResourceAction resAction = new AddTaskAction(PHPEditorMessages.getResourceBundle(), "AddTask.", this); //$NON-NLS-1$
1224     resAction.setHelpContextId(IAbstractTextEditorHelpContextIds.ADD_TASK_ACTION);
1225     resAction.setActionDefinitionId(ITextEditorActionDefinitionIds.ADD_TASK);
1226     setAction(ITextEditorActionConstants.ADD_TASK, resAction);
1227
1228     resAction = new TextOperationAction(PHPEditorMessages.getResourceBundle(), "ShowJavaDoc.", this, ISourceViewer.INFORMATION, true); //$NON-NLS-1$
1229     resAction = new InformationDispatchAction(PHPEditorMessages.getResourceBundle(), "ShowJavaDoc.", (TextOperationAction) resAction); //$NON-NLS-1$
1230     resAction.setActionDefinitionId(PHPEditorActionDefinitionIds.SHOW_JAVADOC);
1231     setAction("ShowJavaDoc", resAction); //$NON-NLS-1$
1232     //                                          WorkbenchHelp.setHelp(resAction, IJavaHelpContextIds.SHOW_JAVADOC_ACTION);
1233
1234     Action action;
1235
1236     setAction(
1237       "ContentAssistTip",
1238       new TextOperationAction(PHPEditorMessages.getResourceBundle(), "ContentAssistTip.", this, ISourceViewer.CONTENTASSIST_CONTEXT_INFORMATION));
1239
1240     action = new ContentAssistAction(PHPEditorMessages.getResourceBundle(), "ContentAssistProposal.", this); //$NON-NLS-1$
1241     action.setActionDefinitionId(ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS);
1242     setAction("ContentAssistProposal", action); //$NON-NLS-1$
1243     markAsStateDependentAction("ContentAssistProposal", true); //$NON-NLS-1$
1244     //  WorkbenchHelp.setHelp(action, IJavaHelpContextIds.CONTENT_ASSIST_ACTION);
1245
1246     fEncodingSupport = new DefaultEncodingSupport();
1247     fEncodingSupport.initialize(this);
1248
1249     action = new TextOperationAction(PHPEditorMessages.getResourceBundle(), "Comment.", this, ITextOperationTarget.PREFIX); //$NON-NLS-1$
1250     action.setActionDefinitionId(PHPEditorActionDefinitionIds.COMMENT);
1251     setAction("Comment", action); //$NON-NLS-1$
1252     markAsStateDependentAction("Comment", true); //$NON-NLS-1$
1253     //          WorkbenchHelp.setHelp(action, IJavaHelpContextIds.COMMENT_ACTION);
1254
1255     action = new TextOperationAction(PHPEditorMessages.getResourceBundle(), "Uncomment.", this, ITextOperationTarget.STRIP_PREFIX); //$NON-NLS-1$
1256     action.setActionDefinitionId(PHPEditorActionDefinitionIds.UNCOMMENT);
1257     setAction("Uncomment", action); //$NON-NLS-1$
1258     markAsStateDependentAction("Uncomment", true); //$NON-NLS-1$
1259     //          WorkbenchHelp.setHelp(action, IJavaHelpContextIds.UNCOMMENT_ACTION);
1260
1261     action = new TextOperationAction(PHPEditorMessages.getResourceBundle(), "Format.", this, ISourceViewer.FORMAT); //$NON-NLS-1$
1262     action.setActionDefinitionId(PHPEditorActionDefinitionIds.FORMAT);
1263     setAction("Format", action); //$NON-NLS-1$
1264     markAsStateDependentAction("Format", true); //$NON-NLS-1$
1265     markAsSelectionDependentAction("Format", true); //$NON-NLS-1$
1266     //  WorkbenchHelp.setHelp(action, IJavaHelpContextIds.FORMAT_ACTION);
1267
1268     action = new GotoMatchingBracketAction(this);
1269     action.setActionDefinitionId(PHPEditorActionDefinitionIds.GOTO_MATCHING_BRACKET);
1270     setAction(GotoMatchingBracketAction.GOTO_MATCHING_BRACKET, action);
1271
1272     fGenerateActionGroup = new GenerateActionGroup(this, ITextEditorActionConstants.GROUP_EDIT);
1273
1274     fActionGroups = new CompositeActionGroup(new ActionGroup[] { fGenerateActionGroup });
1275
1276     // We have to keep the context menu group separate to have better control over positioning
1277     fContextMenuGroup = new CompositeActionGroup(new ActionGroup[] { fGenerateActionGroup });
1278     //      rg,
1279     //      new LocalHistoryActionGroup(this, ITextEditorActionConstants.GROUP_EDIT)});
1280
1281     //    if (fValidationThread == null) {
1282     //      fValidationThread =
1283     //        new PHPSyntaxParserThread(this, getSourceViewer());
1284     //      //Thread defaults
1285     //
1286     //      fValidationThread.start();
1287     //    }
1288     //
1289     //    fValidationThread.setText(getSourceViewer().getTextWidget().getText());
1290   }
1291
1292   /** The <code>PHPEditor</code> implementation of this
1293    * <code>AbstractTextEditor</code> method performs any extra
1294    * disposal actions required by the php editor.
1295    */
1296   public void dispose() {
1297     //   PHPEditorEnvironment.disconnect(this);
1298     if (fOutlinePage != null)
1299       fOutlinePage.setInput(null);
1300
1301     if (fActionGroups != null)
1302       fActionGroups.dispose();
1303
1304     if (isBrowserLikeLinks())
1305       disableBrowserLikeLinks();
1306
1307     if (fEncodingSupport != null) {
1308       fEncodingSupport.dispose();
1309       fEncodingSupport = null;
1310     }
1311
1312     if (fPropertyChangeListener != null) {
1313       Preferences preferences = PHPeclipsePlugin.getDefault().getPluginPreferences();
1314       preferences.removePropertyChangeListener(fPropertyChangeListener);
1315       fPropertyChangeListener = null;
1316     }
1317
1318     if (fSourceViewerDecorationSupport != null) {
1319       fSourceViewerDecorationSupport.dispose();
1320       fSourceViewerDecorationSupport = null;
1321     }
1322
1323     if (fBracketMatcher != null) {
1324       fBracketMatcher.dispose();
1325       fBracketMatcher = null;
1326     }
1327     super.dispose();
1328   }
1329
1330   /** The <code>PHPEditor</code> implementation of this
1331    * <code>AbstractTextEditor</code> method performs any extra
1332    * revert behavior required by the php editor.
1333    */
1334   //  public void doRevertToSaved() {
1335   //    super.doRevertToSaved();
1336   //    if (fOutlinePage != null)
1337   //      fOutlinePage.update();
1338   //  }
1339
1340   /** The <code>PHPEditor</code> implementation of this
1341    * <code>AbstractTextEditor</code> method performs any extra
1342    * save behavior required by the php editor.
1343    */
1344   //  public void doSave(IProgressMonitor monitor) {
1345   //    super.doSave(monitor);
1346   // compile or not, according to the user preferences
1347   // IPreferenceStore store = getPreferenceStore();
1348
1349   // the parse on save was changed to the eclipse "builders" concept
1350   //    if (store.getBoolean(PHPeclipsePlugin.PHP_PARSE_ON_SAVE)) {
1351   //      IAction a = PHPParserAction.getInstance();
1352   //      if (a != null)
1353   //        a.run();
1354   //    }
1355
1356   //    if (SWT.getPlatform().equals("win32")) {
1357   //      IAction a = ShowExternalPreviewAction.getInstance();
1358   //      if (a != null)
1359   //        a.run();
1360   //    }
1361   //    if (fOutlinePage != null)
1362   //      fOutlinePage.update();
1363   //  }
1364
1365   /** The <code>PHPEditor</code> implementation of this
1366    * <code>AbstractTextEditor</code> method performs any extra
1367    * save as behavior required by the php editor.
1368    */
1369   //  public void doSaveAs() {
1370   //    super.doSaveAs();
1371   //    if (fOutlinePage != null)
1372   //      fOutlinePage.update();
1373   //  }
1374   /*
1375          * @see StatusTextEditor#getStatusHeader(IStatus)
1376          */
1377   protected String getStatusHeader(IStatus status) {
1378     if (fEncodingSupport != null) {
1379       String message = fEncodingSupport.getStatusHeader(status);
1380       if (message != null)
1381         return message;
1382     }
1383     return super.getStatusHeader(status);
1384   }
1385
1386   /*
1387    * @see StatusTextEditor#getStatusBanner(IStatus)
1388    */
1389   protected String getStatusBanner(IStatus status) {
1390     if (fEncodingSupport != null) {
1391       String message = fEncodingSupport.getStatusBanner(status);
1392       if (message != null)
1393         return message;
1394     }
1395     return super.getStatusBanner(status);
1396   }
1397
1398   /*
1399    * @see StatusTextEditor#getStatusMessage(IStatus)
1400    */
1401   protected String getStatusMessage(IStatus status) {
1402     if (fEncodingSupport != null) {
1403       String message = fEncodingSupport.getStatusMessage(status);
1404       if (message != null)
1405         return message;
1406     }
1407     return super.getStatusMessage(status);
1408   }
1409   /** The <code>PHPEditor</code> implementation of this
1410    * <code>AbstractTextEditor</code> method performs sets the
1411    * input of the outline page after AbstractTextEditor has set input.
1412    */
1413   //  protected void doSetInput(IEditorInput input) throws CoreException {
1414   //    super.doSetInput(input);
1415   //
1416   //    if (fEncodingSupport != null)
1417   //      fEncodingSupport.reset();
1418   //    if (fOutlinePage != null)
1419   //      fOutlinePage.setInput(input);
1420   //    //              setOutlinePageInput(fOutlinePage, input);
1421   //  }
1422   protected void doSetInput(IEditorInput input) throws CoreException {
1423     super.doSetInput(input);
1424     if (fEncodingSupport != null)
1425       fEncodingSupport.reset();
1426     setOutlinePageInput(fOutlinePage, input);
1427   }
1428   /*
1429    * @see org.phpeclipse.phpdt.internal.ui.viewsupport.IViewPartInputProvider#getViewPartInput()
1430    */
1431   //  public Object getViewPartInput() {
1432   //    return getEditorInput().getAdapter(IFile.class);
1433   //  }
1434
1435   /** The <code>PHPEditor</code> implementation of this
1436    * <code>AbstractTextEditor</code> method adds any
1437    * PHPEditor specific entries.
1438    */
1439   public void editorContextMenuAboutToShow(MenuManager menu) {
1440     super.editorContextMenuAboutToShow(menu);
1441     menu.appendToGroup(ITextEditorActionConstants.GROUP_UNDO, new Separator(IContextMenuConstants.GROUP_OPEN));
1442     menu.insertAfter(IContextMenuConstants.GROUP_OPEN, new GroupMarker(IContextMenuConstants.GROUP_SHOW));
1443
1444     ActionContext context = new ActionContext(getSelectionProvider().getSelection());
1445     fContextMenuGroup.setContext(context);
1446     fContextMenuGroup.fillContextMenu(menu);
1447     fContextMenuGroup.setContext(null);
1448     //    addAction(menu, ITextEditorActionConstants.GROUP_EDIT, "Format"); //$NON-NLS-1$
1449     //
1450     //    ActionContext context =
1451     //      new ActionContext(getSelectionProvider().getSelection());
1452     //    fContextMenuGroup.setContext(context);
1453     //    fContextMenuGroup.fillContextMenu(menu);
1454     //    fContextMenuGroup.setContext(null);
1455   }
1456
1457   /**
1458    * Creates the outline page used with this editor.
1459    */
1460   protected JavaOutlinePage createOutlinePage() {
1461
1462     //    AbstractContentOutlinePage page = new PHPContentOutlinePage(getDocumentProvider(), this);
1463     //
1464     //    page.addSelectionChangedListener(fSelectionChangedListener);
1465     //    //    setOutlinePageInput(page, getEditorInput());
1466     //    if (getEditorInput() != null)
1467     //      fOutlinePage.setInput(getEditorInput());
1468     //
1469     //    return page;
1470     JavaOutlinePage page = new JavaOutlinePage(fOutlinerContextMenuId, this);
1471
1472     page.addSelectionChangedListener(fSelectionChangedListener);
1473     setOutlinePageInput(page, getEditorInput());
1474
1475     return page;
1476   }
1477
1478   /**
1479    * Informs the editor that its outliner has been closed.
1480    */
1481   public void outlinePageClosed() {
1482     if (fOutlinePage != null) {
1483       fOutlinePage.removeSelectionChangedListener(fSelectionChangedListener);
1484       fOutlinePage = null;
1485       resetHighlightRange();
1486     }
1487   }
1488   /**
1489    * Synchronizes the outliner selection with the actual cursor
1490    * position in the editor.
1491    */
1492   public void synchronizeOutlinePageSelection() {
1493
1494     //          if (isEditingScriptRunning())
1495     //                  return;
1496
1497     ISourceViewer sourceViewer = getSourceViewer();
1498     if (sourceViewer == null || fOutlinePage == null)
1499       return;
1500
1501     StyledText styledText = sourceViewer.getTextWidget();
1502     if (styledText == null)
1503       return;
1504
1505     int caret = 0;
1506     if (sourceViewer instanceof ITextViewerExtension3) {
1507       ITextViewerExtension3 extension = (ITextViewerExtension3) sourceViewer;
1508       caret = extension.widgetOffset2ModelOffset(styledText.getCaretOffset());
1509     } else {
1510       int offset = sourceViewer.getVisibleRegion().getOffset();
1511       caret = offset + styledText.getCaretOffset();
1512     }
1513
1514     IJavaElement element = getElementAt(caret);
1515     if (element instanceof ISourceReference) {
1516       fOutlinePage.removeSelectionChangedListener(fSelectionChangedListener);
1517       fOutlinePage.select((ISourceReference) element);
1518       fOutlinePage.addSelectionChangedListener(fSelectionChangedListener);
1519     }
1520   }
1521   protected void updateStateDependentActions() {
1522     super.updateStateDependentActions();
1523     fGenerateActionGroup.editorStateChanged();
1524   }
1525
1526   protected void setSelection(ISourceReference reference, boolean moveCursor) {
1527
1528     ISelection selection = getSelectionProvider().getSelection();
1529     if (selection instanceof TextSelection) {
1530       TextSelection textSelection = (TextSelection) selection;
1531       if (textSelection.getOffset() != 0 || textSelection.getLength() != 0)
1532         markInNavigationHistory();
1533     }
1534
1535     if (reference != null) {
1536
1537       StyledText textWidget = null;
1538
1539       ISourceViewer sourceViewer = getSourceViewer();
1540       if (sourceViewer != null)
1541         textWidget = sourceViewer.getTextWidget();
1542
1543       if (textWidget == null)
1544         return;
1545
1546       try {
1547
1548         ISourceRange range = reference.getSourceRange();
1549         if (range == null)
1550           return;
1551
1552         int offset = range.getOffset();
1553         int length = range.getLength();
1554
1555         if (offset < 0 || length < 0)
1556           return;
1557
1558         textWidget.setRedraw(false);
1559
1560         setHighlightRange(offset, length, moveCursor);
1561
1562         if (!moveCursor)
1563           return;
1564
1565         offset = -1;
1566         length = -1;
1567
1568         if (reference instanceof IMember) {
1569           range = ((IMember) reference).getNameRange();
1570           if (range != null) {
1571             offset = range.getOffset();
1572             length = range.getLength();
1573           }
1574         }
1575         //                                      else if (reference instanceof IImportDeclaration) {
1576         //                                              String name= ((IImportDeclaration) reference).getElementName();
1577         //                                              if (name != null && name.length() > 0) {
1578         //                                                      String content= reference.getSource();
1579         //                                                      if (content != null) {
1580         //                                                              offset= range.getOffset() + content.indexOf(name);
1581         //                                                              length= name.length();
1582         //                                                      }
1583         //                                              }
1584         //                                      } else if (reference instanceof IPackageDeclaration) {
1585         //                                              String name= ((IPackageDeclaration) reference).getElementName();
1586         //                                              if (name != null && name.length() > 0) {
1587         //                                                      String content= reference.getSource();
1588         //                                                      if (content != null) {
1589         //                                                              offset= range.getOffset() + content.indexOf(name);
1590         //                                                              length= name.length();
1591         //                                                      }
1592         //                                              }
1593         //                                      }
1594
1595         if (offset > -1 && length > 0) {
1596           sourceViewer.revealRange(offset, length);
1597           sourceViewer.setSelectedRange(offset, length);
1598         }
1599
1600       } catch (JavaModelException x) {
1601       } catch (IllegalArgumentException x) {
1602       } finally {
1603         if (textWidget != null)
1604           textWidget.setRedraw(true);
1605       }
1606
1607     } else if (moveCursor) {
1608       resetHighlightRange();
1609     }
1610
1611     markInNavigationHistory();
1612   }
1613
1614   public void setSelection(IJavaElement element) {
1615
1616     if (element == null || element instanceof ICompilationUnit) { // || element instanceof IClassFile) {
1617       /*
1618        * If the element is an ICompilationUnit this unit is either the input
1619        * of this editor or not being displayed. In both cases, nothing should
1620        * happened. (http://dev.eclipse.org/bugs/show_bug.cgi?id=5128)
1621        */
1622       return;
1623     }
1624
1625     IJavaElement corresponding = getCorrespondingElement(element);
1626     if (corresponding instanceof ISourceReference) {
1627       ISourceReference reference = (ISourceReference) corresponding;
1628       // set hightlight range
1629       setSelection(reference, true);
1630       // set outliner selection
1631       if (fOutlinePage != null) {
1632         fOutlinePage.removeSelectionChangedListener(fSelectionChangedListener);
1633         fOutlinePage.select(reference);
1634         fOutlinePage.addSelectionChangedListener(fSelectionChangedListener);
1635       }
1636     }
1637   }
1638
1639         public synchronized void editingScriptStarted() {
1640                 ++ fIgnoreOutlinePageSelection;
1641         }
1642
1643         public synchronized void editingScriptEnded() {
1644                 -- fIgnoreOutlinePageSelection;
1645         }
1646
1647         public synchronized boolean isEditingScriptRunning() {
1648                 return (fIgnoreOutlinePageSelection > 0);
1649         }
1650
1651   /** The <code>PHPEditor</code> implementation of this
1652    * <code>AbstractTextEditor</code> method performs gets
1653    * the java content outline page if request is for a an
1654    * outline page.
1655    */
1656   public Object getAdapter(Class required) {
1657
1658     if (IContentOutlinePage.class.equals(required)) {
1659       if (fOutlinePage == null)
1660         fOutlinePage = createOutlinePage();
1661       return fOutlinePage;
1662     }
1663
1664     if (IEncodingSupport.class.equals(required))
1665       return fEncodingSupport;
1666
1667     if (required == IShowInTargetList.class) {
1668       return new IShowInTargetList() {
1669         public String[] getShowInTargetIds() {
1670           return new String[] { JavaUI.ID_PACKAGES, IPageLayout.ID_OUTLINE, IPageLayout.ID_RES_NAV };
1671         }
1672
1673       };
1674     }
1675
1676     return super.getAdapter(required);
1677   }
1678   //  public Object getAdapter(Class required) {
1679   //    if (IContentOutlinePage.class.equals(required)) {
1680   //      if (fOutlinePage == null) {
1681   //        fOutlinePage = new PHPContentOutlinePage(getDocumentProvider(), this);
1682   //        if (getEditorInput() != null)
1683   //          fOutlinePage.setInput(getEditorInput());
1684   //      }
1685   //      return fOutlinePage;
1686   //    }
1687   //
1688   //    if (IEncodingSupport.class.equals(required))
1689   //      return fEncodingSupport;
1690   //
1691   //    return super.getAdapter(required);
1692   //  }
1693
1694   protected void doSelectionChanged(SelectionChangedEvent event) {
1695     ISourceReference reference = null;
1696
1697     ISelection selection = event.getSelection();
1698     Iterator iter = ((IStructuredSelection) selection).iterator();
1699     while (iter.hasNext()) {
1700       Object o = iter.next();
1701       if (o instanceof ISourceReference) {
1702         reference = (ISourceReference) o;
1703         break;
1704       }
1705     }
1706
1707     if (!isActivePart() && PHPeclipsePlugin.getActivePage() != null)
1708       PHPeclipsePlugin.getActivePage().bringToTop(this);
1709
1710     try {
1711       editingScriptStarted();
1712       setSelection(reference, !isActivePart());
1713     } finally {
1714       editingScriptEnded();
1715     }
1716   }
1717   /*
1718          * @see AbstractTextEditor#adjustHighlightRange(int, int)
1719          */
1720   protected void adjustHighlightRange(int offset, int length) {
1721
1722     try {
1723
1724       IJavaElement element = getElementAt(offset);
1725       while (element instanceof ISourceReference) {
1726         ISourceRange range = ((ISourceReference) element).getSourceRange();
1727         if (offset < range.getOffset() + range.getLength() && range.getOffset() < offset + length) {
1728           setHighlightRange(range.getOffset(), range.getLength(), true);
1729           if (fOutlinePage != null) {
1730             fOutlinePage.removeSelectionChangedListener(fSelectionChangedListener);
1731             fOutlinePage.select((ISourceReference) element);
1732             fOutlinePage.addSelectionChangedListener(fSelectionChangedListener);
1733           }
1734           return;
1735         }
1736         element = element.getParent();
1737       }
1738
1739     } catch (JavaModelException x) {
1740       PHPeclipsePlugin.log(x.getStatus());
1741     }
1742
1743     resetHighlightRange();
1744   }
1745   protected boolean isActivePart() {
1746     IWorkbenchWindow window = getSite().getWorkbenchWindow();
1747     IPartService service = window.getPartService();
1748     IWorkbenchPart part = service.getActivePart();
1749     return part != null && part.equals(this);
1750   }
1751
1752
1753   //  public void openContextHelp() {
1754   //    IDocument doc = this.getDocumentProvider().getDocument(this.getEditorInput());
1755   //    ITextSelection selection = (ITextSelection) this.getSelectionProvider().getSelection();
1756   //    int pos = selection.getOffset();
1757   //    String word = getFunctionName(doc, pos);
1758   //    openContextHelp(word);
1759   //  }
1760   //
1761   //  private void openContextHelp(String word) {
1762   //    open(word);
1763   //  }
1764   //
1765   //  public static void open(String word) {
1766   //    IHelp help = WorkbenchHelp.getHelpSupport();
1767   //    if (help != null) {
1768   //      IHelpResource helpResource = new PHPFunctionHelpResource(word);
1769   //      WorkbenchHelp.getHelpSupport().displayHelpResource(helpResource);
1770   //    } else {
1771   //      //   showMessage(shell, dialogTitle, ActionMessages.getString("Open help not available"), false); //$NON-NLS-1$
1772   //    }
1773   //  }
1774
1775   //    private String getFunctionName(IDocument doc, int pos) {
1776   //            Point word = PHPWordExtractor.findWord(doc, pos);
1777   //            if (word != null) {
1778   //                    try {
1779   //                            return doc.get(word.x, word.y).replace('_', '-');
1780   //                    } catch (BadLocationException e) {
1781   //                    }
1782   //            }
1783   //            return "";
1784   //    }
1785
1786   /*
1787    * @see AbstractTextEditor#handlePreferenceStoreChanged(PropertyChangeEvent)
1788    */
1789   protected void handlePreferenceStoreChanged(PropertyChangeEvent event) {
1790
1791     try {
1792
1793       ISourceViewer sourceViewer = getSourceViewer();
1794       if (sourceViewer == null)
1795         return;
1796
1797       String property = event.getProperty();
1798
1799       if (PreferenceConstants.EDITOR_TAB_WIDTH.equals(property)) {
1800         Object value = event.getNewValue();
1801         if (value instanceof Integer) {
1802           sourceViewer.getTextWidget().setTabs(((Integer) value).intValue());
1803         } else if (value instanceof String) {
1804           sourceViewer.getTextWidget().setTabs(Integer.parseInt((String) value));
1805         }
1806         return;
1807       }
1808
1809       if (OVERVIEW_RULER.equals(property)) {
1810         if (isOverviewRulerVisible())
1811           showOverviewRuler();
1812         else
1813           hideOverviewRuler();
1814         return;
1815       }
1816
1817       if (LINE_NUMBER_RULER.equals(property)) {
1818         if (isLineNumberRulerVisible())
1819           showLineNumberRuler();
1820         else
1821           hideLineNumberRuler();
1822         return;
1823       }
1824
1825       if (fLineNumberRulerColumn != null
1826         && (LINE_NUMBER_COLOR.equals(property) || PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT.equals(property) || PREFERENCE_COLOR_BACKGROUND.equals(property))) {
1827
1828         initializeLineNumberRulerColumn(fLineNumberRulerColumn);
1829       }
1830
1831       if (isJavaEditorHoverProperty(property))
1832         updateHoverBehavior();
1833
1834       if (BROWSER_LIKE_LINKS.equals(property)) {
1835         if (isBrowserLikeLinks())
1836           enableBrowserLikeLinks();
1837         else
1838           disableBrowserLikeLinks();
1839         return;
1840       }
1841
1842     } finally {
1843       super.handlePreferenceStoreChanged(event);
1844     }
1845   }
1846
1847   //  /*
1848   //     * @see AbstractTextEditor#handlePreferenceStoreChanged(PropertyChangeEvent)
1849   //     */
1850   //  protected void handlePreferenceStoreChanged(PropertyChangeEvent event) {
1851   //
1852   //    try {
1853   //
1854   //      ISourceViewer sourceViewer = getSourceViewer();
1855   //      if (sourceViewer == null)
1856   //        return;
1857   //
1858   //      String property = event.getProperty();
1859   //
1860   //      //      if (JavaSourceViewerConfiguration.PREFERENCE_TAB_WIDTH.equals(property)) {
1861   //      //        Object value= event.getNewValue();
1862   //      //        if (value instanceof Integer) {
1863   //      //          sourceViewer.getTextWidget().setTabs(((Integer) value).intValue());
1864   //      //        } else if (value instanceof String) {
1865   //      //          sourceViewer.getTextWidget().setTabs(Integer.parseInt((String) value));
1866   //      //        }
1867   //      //        return;
1868   //      //      }
1869   //
1870   //      if (IPreferenceConstants.LINE_NUMBER_RULER.equals(property)) {
1871   //        if (isLineNumberRulerVisible())
1872   //          showLineNumberRuler();
1873   //        else
1874   //          hideLineNumberRuler();
1875   //        return;
1876   //      }
1877   //
1878   //      if (fLineNumberRulerColumn != null
1879   //        && (IPreferenceConstants.LINE_NUMBER_COLOR.equals(property)
1880   //          || PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT.equals(property)
1881   //          || PREFERENCE_COLOR_BACKGROUND.equals(property))) {
1882   //
1883   //        initializeLineNumberRulerColumn(fLineNumberRulerColumn);
1884   //      }
1885   //
1886   //    } finally {
1887   //      super.handlePreferenceStoreChanged(event);
1888   //    }
1889   //  }
1890
1891   //  private boolean isJavaEditorHoverProperty(String property) {
1892   //    return PreferenceConstants.EDITOR_DEFAULT_HOVER.equals(property)
1893   //      || PreferenceConstants.EDITOR_NONE_HOVER.equals(property)
1894   //      || PreferenceConstants.EDITOR_CTRL_HOVER.equals(property)
1895   //      || PreferenceConstants.EDITOR_SHIFT_HOVER.equals(property)
1896   //      || PreferenceConstants.EDITOR_CTRL_ALT_HOVER.equals(property)
1897   //      || PreferenceConstants.EDITOR_CTRL_SHIFT_HOVER.equals(property)
1898   //      || PreferenceConstants.EDITOR_CTRL_ALT_SHIFT_HOVER.equals(property)
1899   //      || PreferenceConstants.EDITOR_ALT_SHIFT_HOVER.equals(property);
1900   //  }
1901
1902   /**
1903    * Shows the line number ruler column.
1904    */
1905   private void showLineNumberRuler() {
1906     IVerticalRuler v = getVerticalRuler();
1907     if (v instanceof CompositeRuler) {
1908       CompositeRuler c = (CompositeRuler) v;
1909       c.addDecorator(1, createLineNumberRulerColumn());
1910     }
1911   }
1912   private boolean isJavaEditorHoverProperty(String property) {
1913     return PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIERS.equals(property);
1914   }
1915
1916   /**
1917          * Return whether the browser like links should be enabled
1918          * according to the preference store settings.
1919          * @return <code>true</code> if the browser like links should be enabled
1920          */
1921   private boolean isBrowserLikeLinks() {
1922     IPreferenceStore store = getPreferenceStore();
1923     return store.getBoolean(BROWSER_LIKE_LINKS);
1924   }
1925
1926   /**
1927    * Enables browser like links.
1928    */
1929   private void enableBrowserLikeLinks() {
1930     if (fMouseListener == null) {
1931       fMouseListener = new MouseClickListener();
1932       fMouseListener.install();
1933     }
1934   }
1935
1936   /**
1937    * Disables browser like links.
1938    */
1939   private void disableBrowserLikeLinks() {
1940     if (fMouseListener != null) {
1941       fMouseListener.uninstall();
1942       fMouseListener = null;
1943     }
1944   }
1945   /**
1946    * Handles a property change event describing a change
1947    * of the java core's preferences and updates the preference
1948    * related editor properties.
1949    *
1950    * @param event the property change event
1951    */
1952   protected void handlePreferencePropertyChanged(org.eclipse.core.runtime.Preferences.PropertyChangeEvent event) {
1953     if (COMPILER_TASK_TAGS.equals(event.getProperty())) {
1954       ISourceViewer sourceViewer = getSourceViewer();
1955       if (sourceViewer != null
1956         && affectsTextPresentation(new PropertyChangeEvent(event.getSource(), event.getProperty(), event.getOldValue(), event.getNewValue())))
1957         sourceViewer.invalidateTextPresentation();
1958     }
1959   }
1960
1961   /**
1962    * Return whether the line number ruler column should be
1963    * visible according to the preference store settings.
1964    * @return <code>true</code> if the line numbers should be visible
1965    */
1966   private boolean isLineNumberRulerVisible() {
1967     IPreferenceStore store = getPreferenceStore();
1968     return store.getBoolean(LINE_NUMBER_RULER);
1969   }
1970   /**
1971    * Hides the line number ruler column.
1972    */
1973   private void hideLineNumberRuler() {
1974     IVerticalRuler v = getVerticalRuler();
1975     if (v instanceof CompositeRuler) {
1976       CompositeRuler c = (CompositeRuler) v;
1977       try {
1978         c.removeDecorator(1);
1979       } catch (Throwable e) {
1980       }
1981     }
1982   }
1983
1984         /*
1985          * @see AbstractTextEditor#handleCursorPositionChanged()
1986          */
1987         protected void handleCursorPositionChanged() {
1988                 super.handleCursorPositionChanged();
1989                 if (!isEditingScriptRunning() && fUpdater != null)
1990                         fUpdater.post();
1991         }
1992
1993   /**
1994    * Initializes the given line number ruler column from the preference store.
1995    * @param rulerColumn the ruler column to be initialized
1996    */
1997   protected void initializeLineNumberRulerColumn(LineNumberRulerColumn rulerColumn) {
1998     JavaTextTools textTools = PHPeclipsePlugin.getDefault().getJavaTextTools();
1999     IColorManager manager = textTools.getColorManager();
2000
2001     IPreferenceStore store = getPreferenceStore();
2002     if (store != null) {
2003
2004       RGB rgb = null;
2005       // foreground color
2006       if (store.contains(LINE_NUMBER_COLOR)) {
2007         if (store.isDefault(LINE_NUMBER_COLOR))
2008           rgb = PreferenceConverter.getDefaultColor(store, LINE_NUMBER_COLOR);
2009         else
2010           rgb = PreferenceConverter.getColor(store, LINE_NUMBER_COLOR);
2011       }
2012       rulerColumn.setForeground(manager.getColor(rgb));
2013
2014       rgb = null;
2015       // background color
2016       if (!store.getBoolean(PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT)) {
2017         if (store.contains(PREFERENCE_COLOR_BACKGROUND)) {
2018           if (store.isDefault(PREFERENCE_COLOR_BACKGROUND))
2019             rgb = PreferenceConverter.getDefaultColor(store, PREFERENCE_COLOR_BACKGROUND);
2020           else
2021             rgb = PreferenceConverter.getColor(store, PREFERENCE_COLOR_BACKGROUND);
2022         }
2023       }
2024       rulerColumn.setBackground(manager.getColor(rgb));
2025     }
2026   }
2027
2028   /**
2029    * Creates a new line number ruler column that is appropriately initialized.
2030    */
2031   protected IVerticalRulerColumn createLineNumberRulerColumn() {
2032     fLineNumberRulerColumn = new LineNumberRulerColumn();
2033     initializeLineNumberRulerColumn(fLineNumberRulerColumn);
2034     return fLineNumberRulerColumn;
2035   }
2036
2037   /*
2038    * @see AbstractTextEditor#createVerticalRuler()
2039    */
2040   protected IVerticalRuler createVerticalRuler() {
2041     CompositeRuler ruler = new CompositeRuler();
2042     ruler.addDecorator(0, new AnnotationRulerColumn(VERTICAL_RULER_WIDTH));
2043     if (isLineNumberRulerVisible())
2044       ruler.addDecorator(1, createLineNumberRulerColumn());
2045     return ruler;
2046   }
2047
2048   private static IRegion getSignedSelection(ITextViewer viewer) {
2049
2050     StyledText text = viewer.getTextWidget();
2051     int caretOffset = text.getCaretOffset();
2052     Point selection = text.getSelection();
2053
2054     // caret left
2055     int offset, length;
2056     if (caretOffset == selection.x) {
2057       offset = selection.y;
2058       length = selection.x - selection.y;
2059
2060       // caret right
2061     } else {
2062       offset = selection.x;
2063       length = selection.y - selection.x;
2064     }
2065
2066     return new Region(offset, length);
2067   }
2068
2069   /** Preference key for matching brackets */
2070   protected final static String MATCHING_BRACKETS = PreferenceConstants.EDITOR_MATCHING_BRACKETS;
2071   /** Preference key for matching brackets color */
2072   protected final static String MATCHING_BRACKETS_COLOR = PreferenceConstants.EDITOR_MATCHING_BRACKETS_COLOR;
2073   /** Preference key for highlighting current line */
2074   protected final static String CURRENT_LINE = PreferenceConstants.EDITOR_CURRENT_LINE;
2075   /** Preference key for highlight color of current line */
2076   protected final static String CURRENT_LINE_COLOR = PreferenceConstants.EDITOR_CURRENT_LINE_COLOR;
2077   /** Preference key for showing print marging ruler */
2078   protected final static String PRINT_MARGIN = PreferenceConstants.EDITOR_PRINT_MARGIN;
2079   /** Preference key for print margin ruler color */
2080   protected final static String PRINT_MARGIN_COLOR = PreferenceConstants.EDITOR_PRINT_MARGIN_COLOR;
2081   /** Preference key for print margin ruler column */
2082   protected final static String PRINT_MARGIN_COLUMN = PreferenceConstants.EDITOR_PRINT_MARGIN_COLUMN;
2083   /** Preference key for error indication */
2084   protected final static String ERROR_INDICATION = PreferenceConstants.EDITOR_PROBLEM_INDICATION;
2085   /** Preference key for error color */
2086   protected final static String ERROR_INDICATION_COLOR = PreferenceConstants.EDITOR_PROBLEM_INDICATION_COLOR;
2087   /** Preference key for warning indication */
2088   protected final static String WARNING_INDICATION = PreferenceConstants.EDITOR_WARNING_INDICATION;
2089   /** Preference key for warning color */
2090   protected final static String WARNING_INDICATION_COLOR = PreferenceConstants.EDITOR_WARNING_INDICATION_COLOR;
2091   /** Preference key for task indication */
2092   protected final static String TASK_INDICATION = PreferenceConstants.EDITOR_TASK_INDICATION;
2093   /** Preference key for task color */
2094   protected final static String TASK_INDICATION_COLOR = PreferenceConstants.EDITOR_TASK_INDICATION_COLOR;
2095   /** Preference key for bookmark indication */
2096   protected final static String BOOKMARK_INDICATION = PreferenceConstants.EDITOR_BOOKMARK_INDICATION;
2097   /** Preference key for bookmark color */
2098   protected final static String BOOKMARK_INDICATION_COLOR = PreferenceConstants.EDITOR_BOOKMARK_INDICATION_COLOR;
2099   /** Preference key for search result indication */
2100   protected final static String SEARCH_RESULT_INDICATION = PreferenceConstants.EDITOR_SEARCH_RESULT_INDICATION;
2101   /** Preference key for search result color */
2102   protected final static String SEARCH_RESULT_INDICATION_COLOR = PreferenceConstants.EDITOR_SEARCH_RESULT_INDICATION_COLOR;
2103   /** Preference key for unknown annotation indication */
2104   protected final static String UNKNOWN_INDICATION = PreferenceConstants.EDITOR_UNKNOWN_INDICATION;
2105   /** Preference key for unknown annotation color */
2106   protected final static String UNKNOWN_INDICATION_COLOR = PreferenceConstants.EDITOR_UNKNOWN_INDICATION_COLOR;
2107   /** Preference key for shwoing the overview ruler */
2108   protected final static String OVERVIEW_RULER = PreferenceConstants.EDITOR_OVERVIEW_RULER;
2109   /** Preference key for error indication in overview ruler */
2110   protected final static String ERROR_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_ERROR_INDICATION_IN_OVERVIEW_RULER;
2111   /** Preference key for warning indication in overview ruler */
2112   protected final static String WARNING_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_WARNING_INDICATION_IN_OVERVIEW_RULER;
2113   /** Preference key for task indication in overview ruler */
2114   protected final static String TASK_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_TASK_INDICATION_IN_OVERVIEW_RULER;
2115   /** Preference key for bookmark indication in overview ruler */
2116   protected final static String BOOKMARK_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_BOOKMARK_INDICATION_IN_OVERVIEW_RULER;
2117   /** Preference key for search result indication in overview ruler */
2118   protected final static String SEARCH_RESULT_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_SEARCH_RESULT_INDICATION_IN_OVERVIEW_RULER;
2119   /** Preference key for unknown annotation indication in overview ruler */
2120   protected final static String UNKNOWN_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_UNKNOWN_INDICATION_IN_OVERVIEW_RULER;
2121   //            /** Preference key for compiler task tags */
2122   //            private final static String COMPILER_TASK_TAGS= JavaCore.COMPILER_TASK_TAGS;
2123   /** Preference key for browser like links */
2124   private final static String BROWSER_LIKE_LINKS = PreferenceConstants.EDITOR_BROWSER_LIKE_LINKS;
2125   /** Preference key for key modifier of browser like links */
2126   private final static String BROWSER_LIKE_LINKS_KEY_MODIFIER = PreferenceConstants.EDITOR_BROWSER_LIKE_LINKS_KEY_MODIFIER;
2127   /**
2128    * Preference key for key modifier mask of browser like links.
2129    * The value is only used if the value of <code>EDITOR_BROWSER_LIKE_LINKS</code>
2130    * cannot be resolved to valid SWT modifier bits.
2131    *
2132    * @since 2.1.1
2133    */
2134   private final static String BROWSER_LIKE_LINKS_KEY_MODIFIER_MASK = PreferenceConstants.EDITOR_BROWSER_LIKE_LINKS_KEY_MODIFIER_MASK;
2135
2136   private final static char[] BRACKETS = { '{', '}', '(', ')', '[', ']' };
2137
2138   private static boolean isBracket(char character) {
2139     for (int i = 0; i != BRACKETS.length; ++i)
2140       if (character == BRACKETS[i])
2141         return true;
2142     return false;
2143   }
2144
2145   private static boolean isSurroundedByBrackets(IDocument document, int offset) {
2146     if (offset == 0 || offset == document.getLength())
2147       return false;
2148
2149     try {
2150       return isBracket(document.getChar(offset - 1)) && isBracket(document.getChar(offset));
2151
2152     } catch (BadLocationException e) {
2153       return false;
2154     }
2155   }
2156
2157   protected void configureSourceViewerDecorationSupport() {
2158
2159     fSourceViewerDecorationSupport.setCharacterPairMatcher(fBracketMatcher);
2160
2161     fSourceViewerDecorationSupport.setAnnotationPainterPreferenceKeys(
2162       AnnotationType.UNKNOWN,
2163       UNKNOWN_INDICATION_COLOR,
2164       UNKNOWN_INDICATION,
2165       UNKNOWN_INDICATION_IN_OVERVIEW_RULER,
2166       0);
2167     fSourceViewerDecorationSupport.setAnnotationPainterPreferenceKeys(
2168       AnnotationType.BOOKMARK,
2169       BOOKMARK_INDICATION_COLOR,
2170       BOOKMARK_INDICATION,
2171       BOOKMARK_INDICATION_IN_OVERVIEW_RULER,
2172       1);
2173     fSourceViewerDecorationSupport.setAnnotationPainterPreferenceKeys(
2174       AnnotationType.TASK,
2175       TASK_INDICATION_COLOR,
2176       TASK_INDICATION,
2177       TASK_INDICATION_IN_OVERVIEW_RULER,
2178       2);
2179     fSourceViewerDecorationSupport.setAnnotationPainterPreferenceKeys(
2180       AnnotationType.SEARCH,
2181       SEARCH_RESULT_INDICATION_COLOR,
2182       SEARCH_RESULT_INDICATION,
2183       SEARCH_RESULT_INDICATION_IN_OVERVIEW_RULER,
2184       3);
2185     fSourceViewerDecorationSupport.setAnnotationPainterPreferenceKeys(
2186       AnnotationType.WARNING,
2187       WARNING_INDICATION_COLOR,
2188       WARNING_INDICATION,
2189       WARNING_INDICATION_IN_OVERVIEW_RULER,
2190       4);
2191     fSourceViewerDecorationSupport.setAnnotationPainterPreferenceKeys(
2192       AnnotationType.ERROR,
2193       ERROR_INDICATION_COLOR,
2194       ERROR_INDICATION,
2195       ERROR_INDICATION_IN_OVERVIEW_RULER,
2196       5);
2197
2198     fSourceViewerDecorationSupport.setCursorLinePainterPreferenceKeys(CURRENT_LINE, CURRENT_LINE_COLOR);
2199     fSourceViewerDecorationSupport.setMarginPainterPreferenceKeys(PRINT_MARGIN, PRINT_MARGIN_COLOR, PRINT_MARGIN_COLUMN);
2200     fSourceViewerDecorationSupport.setMatchingCharacterPainterPreferenceKeys(MATCHING_BRACKETS, MATCHING_BRACKETS_COLOR);
2201
2202     fSourceViewerDecorationSupport.setSymbolicFontName(getFontPropertyPreferenceKey());
2203
2204   }
2205   /**
2206     * Jumps to the matching bracket.
2207     */
2208   public void gotoMatchingBracket() {
2209
2210     ISourceViewer sourceViewer = getSourceViewer();
2211     IDocument document = sourceViewer.getDocument();
2212     if (document == null)
2213       return;
2214
2215     IRegion selection = getSignedSelection(sourceViewer);
2216
2217     int selectionLength = Math.abs(selection.getLength());
2218     if (selectionLength > 1) {
2219       setStatusLineErrorMessage(PHPEditorMessages.getString("GotoMatchingBracket.error.invalidSelection")); //$NON-NLS-1$
2220       sourceViewer.getTextWidget().getDisplay().beep();
2221       return;
2222     }
2223
2224     // #26314
2225     int sourceCaretOffset = selection.getOffset() + selection.getLength();
2226     if (isSurroundedByBrackets(document, sourceCaretOffset))
2227       sourceCaretOffset -= selection.getLength();
2228
2229     IRegion region = fBracketMatcher.match(document, sourceCaretOffset);
2230     if (region == null) {
2231       setStatusLineErrorMessage(PHPEditorMessages.getString("GotoMatchingBracket.error.noMatchingBracket")); //$NON-NLS-1$
2232       sourceViewer.getTextWidget().getDisplay().beep();
2233       return;
2234     }
2235
2236     int offset = region.getOffset();
2237     int length = region.getLength();
2238
2239     if (length < 1)
2240       return;
2241
2242     int anchor = fBracketMatcher.getAnchor();
2243     int targetOffset = (PHPPairMatcher.RIGHT == anchor) ? offset : offset + length - 1;
2244
2245     boolean visible = false;
2246     if (sourceViewer instanceof ITextViewerExtension3) {
2247       ITextViewerExtension3 extension = (ITextViewerExtension3) sourceViewer;
2248       visible = (extension.modelOffset2WidgetOffset(targetOffset) > -1);
2249     } else {
2250       IRegion visibleRegion = sourceViewer.getVisibleRegion();
2251       visible = (targetOffset >= visibleRegion.getOffset() && targetOffset < visibleRegion.getOffset() + visibleRegion.getLength());
2252     }
2253
2254     if (!visible) {
2255       setStatusLineErrorMessage(PHPEditorMessages.getString("GotoMatchingBracket.error.bracketOutsideSelectedElement")); //$NON-NLS-1$
2256       sourceViewer.getTextWidget().getDisplay().beep();
2257       return;
2258     }
2259
2260     if (selection.getLength() < 0)
2261       targetOffset -= selection.getLength();
2262
2263     sourceViewer.setSelectedRange(targetOffset, selection.getLength());
2264     sourceViewer.revealRange(targetOffset, selection.getLength());
2265   }
2266   /**
2267      * Ses the given message as error message to this editor's status line.
2268      * @param msg message to be set
2269      */
2270   protected void setStatusLineErrorMessage(String msg) {
2271     IEditorStatusLine statusLine = (IEditorStatusLine) getAdapter(IEditorStatusLine.class);
2272     if (statusLine != null)
2273       statusLine.setMessage(true, msg, null);
2274   }
2275
2276   /**
2277      * Returns a segmentation of the line of the given document appropriate for bidi rendering.
2278      * The default implementation returns only the string literals of a php code line as segments.
2279      *
2280      * @param document the document
2281      * @param lineOffset the offset of the line
2282      * @return the line's bidi segmentation
2283      * @throws BadLocationException in case lineOffset is not valid in document
2284      */
2285   public static int[] getBidiLineSegments(IDocument document, int lineOffset) throws BadLocationException {
2286
2287     IRegion line = document.getLineInformationOfOffset(lineOffset);
2288     ITypedRegion[] linePartitioning = document.computePartitioning(lineOffset, line.getLength());
2289
2290     List segmentation = new ArrayList();
2291     for (int i = 0; i < linePartitioning.length; i++) {
2292       if (IPHPPartitionScannerConstants.PHP_STRING.equals(linePartitioning[i].getType()))
2293         segmentation.add(linePartitioning[i]);
2294     }
2295
2296     if (segmentation.size() == 0)
2297       return null;
2298
2299     int size = segmentation.size();
2300     int[] segments = new int[size * 2 + 1];
2301
2302     int j = 0;
2303     for (int i = 0; i < size; i++) {
2304       ITypedRegion segment = (ITypedRegion) segmentation.get(i);
2305
2306       if (i == 0)
2307         segments[j++] = 0;
2308
2309       int offset = segment.getOffset() - lineOffset;
2310       if (offset > segments[j - 1])
2311         segments[j++] = offset;
2312
2313       if (offset + segment.getLength() >= line.getLength())
2314         break;
2315
2316       segments[j++] = offset + segment.getLength();
2317     }
2318
2319     if (j < segments.length) {
2320       int[] result = new int[j];
2321       System.arraycopy(segments, 0, result, 0, j);
2322       segments = result;
2323     }
2324
2325     return segments;
2326   }
2327   /**
2328      * Returns a segmentation of the given line appropriate for bidi rendering. The default
2329      * implementation returns only the string literals of a php code line as segments.
2330      *
2331      * @param lineOffset the offset of the line
2332      * @param line the content of the line
2333      * @return the line's bidi segmentation
2334      */
2335   protected int[] getBidiLineSegments(int lineOffset, String line) {
2336     IDocumentProvider provider = getDocumentProvider();
2337     if (provider != null && line != null && line.length() > 0) {
2338       IDocument document = provider.getDocument(getEditorInput());
2339       if (document != null)
2340         try {
2341           return getBidiLineSegments(document, lineOffset);
2342         } catch (BadLocationException x) {
2343           // ignore
2344         }
2345     }
2346     return null;
2347   }
2348
2349   /*
2350    * @see AbstractTextEditor#createSourceViewer(Composite, IVerticalRuler, int)
2351    */
2352   //  protected final ISourceViewer createSourceViewer(
2353   //    Composite parent,
2354   //    IVerticalRuler ruler,
2355   //    int styles) {
2356   //    ISourceViewer viewer = createJavaSourceViewer(parent, ruler, styles);
2357   //    StyledText text = viewer.getTextWidget();
2358   //    text.addBidiSegmentListener(new BidiSegmentListener() {
2359   //      public void lineGetSegments(BidiSegmentEvent event) {
2360   //        event.segments = getBidiLineSegments(event.lineOffset, event.lineText);
2361   //      }
2362   //    });
2363   //    //   JavaUIHelp.setHelp(this, text, IJavaHelpContextIds.JAVA_EDITOR);
2364   //    return viewer;
2365   //  }
2366   protected final ISourceViewer createSourceViewer(Composite parent, IVerticalRuler verticalRuler, int styles) {
2367
2368     ISharedTextColors sharedColors = PHPeclipsePlugin.getDefault().getJavaTextTools().getColorManager();
2369
2370     fOverviewRuler = new OverviewRuler(fAnnotationAccess, VERTICAL_RULER_WIDTH, sharedColors);
2371     fOverviewRuler.addHeaderAnnotationType(AnnotationType.WARNING);
2372     fOverviewRuler.addHeaderAnnotationType(AnnotationType.ERROR);
2373
2374     ISourceViewer viewer = createJavaSourceViewer(parent, verticalRuler, fOverviewRuler, isOverviewRulerVisible(), styles);
2375
2376     StyledText text = viewer.getTextWidget();
2377     text.addBidiSegmentListener(new BidiSegmentListener() {
2378       public void lineGetSegments(BidiSegmentEvent event) {
2379         event.segments = getBidiLineSegments(event.lineOffset, event.lineText);
2380       }
2381     });
2382
2383     //          JavaUIHelp.setHelp(this, text, IJavaHelpContextIds.JAVA_EDITOR);
2384
2385     fSourceViewerDecorationSupport = new SourceViewerDecorationSupport(viewer, fOverviewRuler, fAnnotationAccess, sharedColors);
2386     configureSourceViewerDecorationSupport();
2387
2388     return viewer;
2389   }
2390
2391   protected void showOverviewRuler() {
2392     if (fOverviewRuler != null) {
2393       if (getSourceViewer() instanceof ISourceViewerExtension) {
2394         ((ISourceViewerExtension) getSourceViewer()).showAnnotationsOverview(true);
2395         fSourceViewerDecorationSupport.updateOverviewDecorations();
2396       }
2397     }
2398   }
2399
2400   protected void hideOverviewRuler() {
2401     if (getSourceViewer() instanceof ISourceViewerExtension) {
2402       fSourceViewerDecorationSupport.hideAnnotationOverview();
2403       ((ISourceViewerExtension) getSourceViewer()).showAnnotationsOverview(false);
2404     }
2405   }
2406
2407   protected boolean isOverviewRulerVisible() {
2408     IPreferenceStore store = getPreferenceStore();
2409     return store.getBoolean(OVERVIEW_RULER);
2410   }
2411   /*
2412    * @see AbstractTextEditor#createSourceViewer(Composite, IVerticalRuler, int)
2413    */
2414   protected ISourceViewer createJavaSourceViewer(
2415     Composite parent,
2416     IVerticalRuler ruler,
2417     IOverviewRuler overviewRuler,
2418     boolean isOverviewRulerVisible,
2419     int styles) {
2420     return new SourceViewer(parent, ruler, overviewRuler, isOverviewRulerVisible(), styles);
2421     //    return super.createSourceViewer(parent, ruler, styles);
2422   }
2423
2424   /*
2425    * @see AbstractTextEditor#affectsTextPresentation(PropertyChangeEvent)
2426    */
2427   protected boolean affectsTextPresentation(PropertyChangeEvent event) {
2428     JavaTextTools textTools = PHPeclipsePlugin.getDefault().getJavaTextTools();
2429     return textTools.affectsBehavior(event);
2430   }
2431
2432   /**
2433    * Jumps to the error next according to the given direction.
2434    */
2435   public void gotoError(boolean forward) {
2436
2437     ISelectionProvider provider = getSelectionProvider();
2438
2439     ITextSelection s = (ITextSelection) provider.getSelection();
2440     Position errorPosition = new Position(0, 0);
2441     IJavaAnnotation nextError = getNextError(s.getOffset(), forward, errorPosition);
2442
2443     if (nextError != null) {
2444
2445       IMarker marker = null;
2446       if (nextError instanceof MarkerAnnotation)
2447         marker = ((MarkerAnnotation) nextError).getMarker();
2448       else {
2449         Iterator e = nextError.getOverlaidIterator();
2450         if (e != null) {
2451           while (e.hasNext()) {
2452             Object o = e.next();
2453             if (o instanceof MarkerAnnotation) {
2454               marker = ((MarkerAnnotation) o).getMarker();
2455               break;
2456             }
2457           }
2458         }
2459       }
2460
2461       if (marker != null) {
2462         IWorkbenchPage page = getSite().getPage();
2463         IViewPart view = view = page.findView("org.eclipse.ui.views.TaskList"); //$NON-NLS-1$
2464         if (view instanceof TaskList) {
2465           StructuredSelection ss = new StructuredSelection(marker);
2466           ((TaskList) view).setSelection(ss, true);
2467         }
2468       }
2469
2470       selectAndReveal(errorPosition.getOffset(), errorPosition.getLength());
2471       setStatusLineErrorMessage(nextError.getMessage());
2472
2473     } else {
2474
2475       setStatusLineErrorMessage(null);
2476
2477     }
2478   }
2479
2480   private IJavaAnnotation getNextError(int offset, boolean forward, Position errorPosition) {
2481
2482     IJavaAnnotation nextError = null;
2483     Position nextErrorPosition = null;
2484
2485     IDocument document = getDocumentProvider().getDocument(getEditorInput());
2486     int endOfDocument = document.getLength();
2487     int distance = 0;
2488
2489     IAnnotationModel model = getDocumentProvider().getAnnotationModel(getEditorInput());
2490     Iterator e = new JavaAnnotationIterator(model, false);
2491     while (e.hasNext()) {
2492
2493       IJavaAnnotation a = (IJavaAnnotation) e.next();
2494       if (a.hasOverlay() || !a.isProblem())
2495         continue;
2496
2497       Position p = model.getPosition((Annotation) a);
2498       if (!p.includes(offset)) {
2499
2500         int currentDistance = 0;
2501
2502         if (forward) {
2503           currentDistance = p.getOffset() - offset;
2504           if (currentDistance < 0)
2505             currentDistance = endOfDocument - offset + p.getOffset();
2506         } else {
2507           currentDistance = offset - p.getOffset();
2508           if (currentDistance < 0)
2509             currentDistance = offset + endOfDocument - p.getOffset();
2510         }
2511
2512         if (nextError == null || currentDistance < distance) {
2513           distance = currentDistance;
2514           nextError = a;
2515           nextErrorPosition = p;
2516         }
2517       }
2518     }
2519
2520     if (nextErrorPosition != null) {
2521       errorPosition.setOffset(nextErrorPosition.getOffset());
2522       errorPosition.setLength(nextErrorPosition.getLength());
2523     }
2524
2525     return nextError;
2526   }
2527 }