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