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