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