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