Moved to test plugin to eliminate dependency upon junit plugin
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / phpeditor / PHPUnitEditor.java
1 package net.sourceforge.phpeclipse.phpeditor;
2
3 import java.util.ArrayList;
4 import java.util.HashMap;
5 import java.util.Iterator;
6 import java.util.List;
7 import java.util.Map;
8
9 import net.sourceforge.phpdt.internal.ui.text.ContentAssistPreference;
10 import net.sourceforge.phpdt.internal.ui.text.PHPPairMatcher;
11 import net.sourceforge.phpdt.internal.ui.text.java.IReconcilingParticipant;
12 import net.sourceforge.phpdt.internal.ui.text.link.LinkedPositionManager;
13 import net.sourceforge.phpdt.internal.ui.text.link.LinkedPositionUI;
14 import net.sourceforge.phpdt.internal.ui.text.link.LinkedPositionUI.ExitFlags;
15 import net.sourceforge.phpdt.ui.PreferenceConstants;
16 import net.sourceforge.phpdt.ui.text.JavaTextTools;
17 import net.sourceforge.phpeclipse.PHPCore;
18 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
19
20 import org.eclipse.core.resources.IFile;
21 import org.eclipse.core.runtime.CoreException;
22 import org.eclipse.core.runtime.Preferences;
23 import org.eclipse.core.runtime.Preferences.IPropertyChangeListener;
24 import org.eclipse.jface.preference.IPreferenceStore;
25 import org.eclipse.jface.preference.PreferenceConverter;
26 import org.eclipse.jface.text.AbstractHoverInformationControlManager;
27 import org.eclipse.jface.text.BadLocationException;
28 import org.eclipse.jface.text.DocumentCommand;
29 import org.eclipse.jface.text.IDocument;
30 import org.eclipse.jface.text.ILineTracker;
31 import org.eclipse.jface.text.IRegion;
32 import org.eclipse.jface.text.ITextSelection;
33 import org.eclipse.jface.text.ITextViewerExtension;
34 import org.eclipse.jface.text.ITypedRegion;
35 import org.eclipse.jface.text.IWidgetTokenKeeper;
36 import org.eclipse.jface.text.contentassist.ContentAssistant;
37 import org.eclipse.jface.text.contentassist.IContentAssistant;
38 import org.eclipse.jface.text.source.IAnnotationModel;
39 import org.eclipse.jface.text.source.ISourceViewer;
40 import org.eclipse.jface.text.source.IVerticalRuler;
41 import org.eclipse.jface.text.source.SourceViewer;
42 import org.eclipse.jface.text.source.SourceViewerConfiguration;
43 import org.eclipse.jface.util.PropertyChangeEvent;
44 import org.eclipse.swt.SWT;
45 import org.eclipse.swt.custom.StyledText;
46 import org.eclipse.swt.custom.VerifyKeyListener;
47 import org.eclipse.swt.events.VerifyEvent;
48 import org.eclipse.swt.graphics.Color;
49 import org.eclipse.swt.graphics.Point;
50 import org.eclipse.swt.graphics.RGB;
51 import org.eclipse.swt.graphics.Rectangle;
52 import org.eclipse.swt.widgets.Composite;
53 import org.eclipse.swt.widgets.Control;
54 import org.eclipse.swt.widgets.Display;
55 import org.eclipse.swt.widgets.Layout;
56 import org.eclipse.ui.IEditorInput;
57 import org.eclipse.ui.IFileEditorInput;
58 import org.eclipse.ui.help.WorkbenchHelp;
59 import org.eclipse.ui.texteditor.IDocumentProvider;
60
61 /**********************************************************************
62 Copyright (c) 2000, 2002 IBM Corp. and others.
63 All rights reserved. This program and the accompanying materials
64 are made available under the terms of the Common Public License v1.0
65 which accompanies this distribution, and is available at
66 http://www.eclipse.org/legal/cpl-v10.html
67
68 Contributors:
69     IBM Corporation - Initial implementation
70     Klaus Hartlage - www.eclipseproject.de
71 **********************************************************************/
72 /**
73  * PHP specific text editor.
74  */
75 public class PHPUnitEditor extends PHPEditor {
76   interface ITextConverter {
77     void customizeDocumentCommand(IDocument document, DocumentCommand command);
78   };
79
80   class AdaptedRulerLayout extends Layout {
81
82     protected int fGap;
83     protected AdaptedSourceViewer fAdaptedSourceViewer;
84
85     protected AdaptedRulerLayout(int gap, AdaptedSourceViewer asv) {
86       fGap = gap;
87       fAdaptedSourceViewer = asv;
88     }
89
90     protected Point computeSize(
91       Composite composite,
92       int wHint,
93       int hHint,
94       boolean flushCache) {
95       Control[] children = composite.getChildren();
96       Point s =
97         children[children.length
98           - 1].computeSize(SWT.DEFAULT, SWT.DEFAULT, flushCache);
99       if (fAdaptedSourceViewer.isVerticalRulerVisible())
100         s.x += fAdaptedSourceViewer.getVerticalRuler().getWidth() + fGap;
101       return s;
102     }
103
104     protected void layout(Composite composite, boolean flushCache) {
105       Rectangle clArea = composite.getClientArea();
106       if (fAdaptedSourceViewer.isVerticalRulerVisible()) {
107
108         StyledText textWidget = fAdaptedSourceViewer.getTextWidget();
109         Rectangle trim = textWidget.computeTrim(0, 0, 0, 0);
110         int scrollbarHeight = trim.height;
111
112         IVerticalRuler vr = fAdaptedSourceViewer.getVerticalRuler();
113         int vrWidth = vr.getWidth();
114
115         int orWidth = 0;
116         if (fAdaptedSourceViewer.isOverviewRulerVisible()) {
117           OverviewRuler or = fAdaptedSourceViewer.getOverviewRuler();
118           orWidth = or.getWidth();
119           or.getControl().setBounds(
120             clArea.width - orWidth,
121             scrollbarHeight,
122             orWidth,
123             clArea.height - 3 * scrollbarHeight);
124         }
125
126         textWidget.setBounds(
127           vrWidth + fGap,
128           0,
129           clArea.width - vrWidth - orWidth - 2 * fGap,
130           clArea.height);
131         vr.getControl().setBounds(
132           0,
133           0,
134           vrWidth,
135           clArea.height - scrollbarHeight);
136
137       } else {
138         StyledText textWidget = fAdaptedSourceViewer.getTextWidget();
139         textWidget.setBounds(0, 0, clArea.width, clArea.height);
140       }
141     }
142   };
143
144   class AdaptedSourceViewer
145     extends SourceViewer { // extends JavaCorrectionSourceViewer  {
146
147     private List fTextConverters;
148
149     private OverviewRuler fOverviewRuler;
150     private boolean fIsOverviewRulerVisible;
151     /** The viewer's overview ruler hovering controller */
152     private AbstractHoverInformationControlManager fOverviewRulerHoveringController;
153
154     private boolean fIgnoreTextConverters = false;
155
156     private IVerticalRuler fCachedVerticalRuler;
157     private boolean fCachedIsVerticalRulerVisible;
158
159     public AdaptedSourceViewer(
160       Composite parent,
161       IVerticalRuler ruler,
162       int styles) {
163       super(parent, ruler, styles); //, CompilationUnitEditor.this);
164
165       fCachedVerticalRuler = ruler;
166       fCachedIsVerticalRulerVisible = (ruler != null);
167       fOverviewRuler = new OverviewRuler(VERTICAL_RULER_WIDTH);
168
169       delayedCreateControl(parent, styles);
170     }
171
172     /*
173      * @see ISourceViewer#showAnnotations(boolean)
174      */
175     public void showAnnotations(boolean show) {
176       fCachedIsVerticalRulerVisible = (show && fCachedVerticalRuler != null);
177       //   super.showAnnotations(show);
178     }
179
180     public IContentAssistant getContentAssistant() {
181       return fContentAssistant;
182     }
183
184     /*
185      * @see ITextOperationTarget#doOperation(int)
186      */
187     public void doOperation(int operation) {
188
189       if (getTextWidget() == null)
190         return;
191
192       switch (operation) {
193         case CONTENTASSIST_PROPOSALS :
194           String msg = fContentAssistant.showPossibleCompletions();
195           setStatusLineErrorMessage(msg);
196           return;
197         case UNDO :
198           fIgnoreTextConverters = true;
199           break;
200         case REDO :
201           fIgnoreTextConverters = true;
202           break;
203       }
204
205       super.doOperation(operation);
206     }
207
208     public void insertTextConverter(ITextConverter textConverter, int index) {
209       throw new UnsupportedOperationException();
210     }
211
212     public void addTextConverter(ITextConverter textConverter) {
213       if (fTextConverters == null) {
214         fTextConverters = new ArrayList(1);
215         fTextConverters.add(textConverter);
216       } else if (!fTextConverters.contains(textConverter))
217         fTextConverters.add(textConverter);
218     }
219
220     public void removeTextConverter(ITextConverter textConverter) {
221       if (fTextConverters != null) {
222         fTextConverters.remove(textConverter);
223         if (fTextConverters.size() == 0)
224           fTextConverters = null;
225       }
226     }
227
228     /*
229      * @see TextViewer#customizeDocumentCommand(DocumentCommand)
230      */
231     protected void customizeDocumentCommand(DocumentCommand command) {
232       super.customizeDocumentCommand(command);
233       if (!fIgnoreTextConverters && fTextConverters != null) {
234         for (Iterator e = fTextConverters.iterator(); e.hasNext();)
235           ((ITextConverter) e.next()).customizeDocumentCommand(
236             getDocument(),
237             command);
238       }
239       fIgnoreTextConverters = false;
240     }
241
242     public IVerticalRuler getVerticalRuler() {
243       return fCachedVerticalRuler;
244     }
245
246     public boolean isVerticalRulerVisible() {
247       return fCachedIsVerticalRulerVisible;
248     }
249
250     public OverviewRuler getOverviewRuler() {
251       return fOverviewRuler;
252     }
253
254     /*
255      * @see TextViewer#createControl(Composite, int)
256      */
257     protected void createControl(Composite parent, int styles) {
258       // do nothing here
259     }
260
261     protected void delayedCreateControl(Composite parent, int styles) {
262       //create the viewer
263       super.createControl(parent, styles);
264
265       Control control = getControl();
266       if (control instanceof Composite) {
267         Composite composite = (Composite) control;
268         composite.setLayout(new AdaptedRulerLayout(GAP_SIZE, this));
269         fOverviewRuler.createControl(composite, this);
270       }
271     }
272
273     protected void ensureOverviewHoverManagerInstalled() {
274       if (fOverviewRulerHoveringController == null
275         && fAnnotationHover != null
276         && fHoverControlCreator != null) {
277         fOverviewRulerHoveringController =
278           new OverviewRulerHoverManager(
279             fOverviewRuler,
280             this,
281             fAnnotationHover,
282             fHoverControlCreator);
283         fOverviewRulerHoveringController.install(fOverviewRuler.getControl());
284       }
285     }
286
287     public void hideOverviewRuler() {
288       fIsOverviewRulerVisible = false;
289       Control control = getControl();
290       if (control instanceof Composite) {
291         Composite composite = (Composite) control;
292         composite.layout();
293       }
294       if (fOverviewRulerHoveringController != null) {
295         fOverviewRulerHoveringController.dispose();
296         fOverviewRulerHoveringController = null;
297       }
298     }
299
300     public void showOverviewRuler() {
301       fIsOverviewRulerVisible = true;
302       Control control = getControl();
303       if (control instanceof Composite) {
304         Composite composite = (Composite) control;
305         composite.layout();
306       }
307       ensureOverviewHoverManagerInstalled();
308     }
309
310     public boolean isOverviewRulerVisible() {
311       return fIsOverviewRulerVisible;
312     }
313
314     /*
315      * @see ISourceViewer#setDocument(IDocument, IAnnotationModel, int, int)
316      */
317     public void setDocument(
318       IDocument document,
319       IAnnotationModel annotationModel,
320       int visibleRegionOffset,
321       int visibleRegionLength) {
322       super.setDocument(
323         document,
324         annotationModel,
325         visibleRegionOffset,
326         visibleRegionLength);
327       fOverviewRuler.setModel(annotationModel);
328     }
329
330     // http://dev.eclipse.org/bugs/show_bug.cgi?id=19270
331     public void updateIndentationPrefixes() {
332       SourceViewerConfiguration configuration = getSourceViewerConfiguration();
333       String[] types = configuration.getConfiguredContentTypes(this);
334       for (int i = 0; i < types.length; i++) {
335         String[] prefixes = configuration.getIndentPrefixes(this, types[i]);
336         if (prefixes != null && prefixes.length > 0)
337           setIndentPrefixes(prefixes, types[i]);
338       }
339     }
340
341     /*
342      * @see IWidgetTokenOwner#requestWidgetToken(IWidgetTokenKeeper)
343      */
344     public boolean requestWidgetToken(IWidgetTokenKeeper requester) {
345       if (WorkbenchHelp.isContextHelpDisplayed())
346         return false;
347       return super.requestWidgetToken(requester);
348     }
349
350     /*
351      * @see org.eclipse.jface.text.source.ISourceViewer#configure(org.eclipse.jface.text.source.SourceViewerConfiguration)
352      */
353     public void configure(SourceViewerConfiguration configuration) {
354       super.configure(configuration);
355       //      prependAutoEditStrategy(new SmartBracesAutoEditStrategy(this), IDocument.DEFAULT_CONTENT_TYPE);
356     }
357
358     protected void handleDispose() {
359       fOverviewRuler = null;
360
361       if (fOverviewRulerHoveringController != null) {
362         fOverviewRulerHoveringController.dispose();
363         fOverviewRulerHoveringController = null;
364       }
365
366       super.handleDispose();
367     }
368
369   };
370
371   static class TabConverter implements ITextConverter {
372
373     private int fTabRatio;
374     private ILineTracker fLineTracker;
375
376     public TabConverter() {
377     }
378
379     public void setNumberOfSpacesPerTab(int ratio) {
380       fTabRatio = ratio;
381     }
382
383     public void setLineTracker(ILineTracker lineTracker) {
384       fLineTracker = lineTracker;
385     }
386
387     private int insertTabString(StringBuffer buffer, int offsetInLine) {
388
389       if (fTabRatio == 0)
390         return 0;
391
392       int remainder = offsetInLine % fTabRatio;
393       remainder = fTabRatio - remainder;
394       for (int i = 0; i < remainder; i++)
395         buffer.append(' ');
396       return remainder;
397     }
398
399     public void customizeDocumentCommand(
400       IDocument document,
401       DocumentCommand command) {
402       String text = command.text;
403       if (text == null)
404         return;
405
406       int index = text.indexOf('\t');
407       if (index > -1) {
408
409         StringBuffer buffer = new StringBuffer();
410
411         fLineTracker.set(command.text);
412         int lines = fLineTracker.getNumberOfLines();
413
414         try {
415
416           for (int i = 0; i < lines; i++) {
417
418             int offset = fLineTracker.getLineOffset(i);
419             int endOffset = offset + fLineTracker.getLineLength(i);
420             String line = text.substring(offset, endOffset);
421
422             int position = 0;
423             if (i == 0) {
424               IRegion firstLine =
425                 document.getLineInformationOfOffset(command.offset);
426               position = command.offset - firstLine.getOffset();
427             }
428
429             int length = line.length();
430             for (int j = 0; j < length; j++) {
431               char c = line.charAt(j);
432               if (c == '\t') {
433                 position += insertTabString(buffer, position);
434               } else {
435                 buffer.append(c);
436                 ++position;
437               }
438             }
439
440           }
441
442           command.text = buffer.toString();
443
444         } catch (BadLocationException x) {
445         }
446       }
447     }
448   };
449
450   private static class ExitPolicy implements LinkedPositionUI.ExitPolicy {
451                 
452     final char fExitCharacter;
453                 
454     public ExitPolicy(char exitCharacter) {
455       fExitCharacter= exitCharacter;
456     }
457
458     /*
459      * @see org.phpeclipse.phpdt.internal.ui.text.link.LinkedPositionUI.ExitPolicy#doExit(org.phpeclipse.phpdt.internal.ui.text.link.LinkedPositionManager, org.eclipse.swt.events.VerifyEvent, int, int)
460      */
461     public ExitFlags doExit(LinkedPositionManager manager, VerifyEvent event, int offset, int length) {
462                         
463       if (event.character == fExitCharacter) {
464         if (manager.anyPositionIncludes(offset, length))
465           return new ExitFlags(LinkedPositionUI.COMMIT| LinkedPositionUI.UPDATE_CARET, false);
466         else
467           return new ExitFlags(LinkedPositionUI.COMMIT, true);
468       } 
469                         
470       switch (event.character) {                        
471       case '\b':
472         if (manager.getFirstPosition().length == 0)
473           return new ExitFlags(0, false);
474         else
475           return null;
476                                 
477       case '\n':
478       case '\r':
479         return new ExitFlags(LinkedPositionUI.COMMIT, true);
480                                 
481       default:
482         return null;
483       }                                         
484     }
485
486   }
487   private class BracketInserter implements VerifyKeyListener, LinkedPositionUI.ExitListener {
488                 
489     private boolean fCloseBrackets= true;
490     private boolean fCloseStrings= true;
491                 
492     private int fOffset;
493     private int fLength;
494
495     public void setCloseBracketsEnabled(boolean enabled) {
496       fCloseBrackets= enabled;
497     }
498
499     public void setCloseStringsEnabled(boolean enabled) {
500       fCloseStrings= enabled;
501     }
502
503     private boolean hasIdentifierToTheRight(IDocument document, int offset) {
504       try {
505         int end= offset;
506         IRegion endLine= document.getLineInformationOfOffset(end);
507         int maxEnd= endLine.getOffset() + endLine.getLength();
508         while (end != maxEnd && Character.isWhitespace(document.getChar(end)))
509           ++end;
510
511         return end != maxEnd && Character.isJavaIdentifierPart(document.getChar(end));
512
513       } catch (BadLocationException e) {
514         // be conservative
515         return true;
516       }
517     }
518
519     private boolean hasIdentifierToTheLeft(IDocument document, int offset) {
520       try {
521         int start= offset;
522         IRegion startLine= document.getLineInformationOfOffset(start);
523         int minStart= startLine.getOffset();
524         while (start != minStart && Character.isWhitespace(document.getChar(start - 1)))
525           --start;
526                                 
527         return start != minStart && Character.isJavaIdentifierPart(document.getChar(start - 1));
528
529       } catch (BadLocationException e) {
530         return true;
531       }                 
532     }
533
534     private boolean hasCharacterToTheRight(IDocument document, int offset, char character) {
535       try {
536         int end= offset;
537         IRegion endLine= document.getLineInformationOfOffset(end);
538         int maxEnd= endLine.getOffset() + endLine.getLength();
539         while (end != maxEnd && Character.isWhitespace(document.getChar(end)))
540           ++end;
541                                 
542         return end != maxEnd && document.getChar(end) == character;
543
544
545       } catch (BadLocationException e) {
546         // be conservative
547         return true;
548       }                 
549     }
550                 
551     /*
552      * @see org.eclipse.swt.custom.VerifyKeyListener#verifyKey(org.eclipse.swt.events.VerifyEvent)
553      */
554     public void verifyKey(VerifyEvent event) {                  
555
556       if (!event.doit)
557         return;
558
559       final ISourceViewer sourceViewer= getSourceViewer();
560       IDocument document= sourceViewer.getDocument();
561
562       final Point selection= sourceViewer.getSelectedRange();
563       final int offset= selection.x;
564       final int length= selection.y;
565
566       switch (event.character) {
567       case '(':
568         if (hasCharacterToTheRight(document, offset + length, '('))
569           return;
570
571         // fall through
572
573       case '[':
574           if (!fCloseBrackets)
575             return;
576           if (hasIdentifierToTheRight(document, offset + length))
577             return;
578                         
579         // fall through
580                         
581       case '"':
582         if (event.character == '"') {
583           if (!fCloseStrings)
584             return;
585           if (hasIdentifierToTheLeft(document, offset) || hasIdentifierToTheRight(document, offset + length))
586             return;
587         }
588                                 
589         try {           
590           ITypedRegion partition= document.getPartition(offset);
591           if (! IDocument.DEFAULT_CONTENT_TYPE.equals(partition.getType()) && partition.getOffset() != offset)
592             return;
593
594           final char character= event.character;
595           final char closingCharacter= getPeerCharacter(character);             
596           final StringBuffer buffer= new StringBuffer();
597           buffer.append(character);
598           buffer.append(closingCharacter);
599
600           document.replace(offset, length, buffer.toString());
601
602           LinkedPositionManager manager= new LinkedPositionManager(document);
603           manager.addPosition(offset + 1, 0);
604
605           fOffset= offset;
606           fLength= 2;
607                         
608           LinkedPositionUI editor= new LinkedPositionUI(sourceViewer, manager);
609           editor.setCancelListener(this);
610           editor.setExitPolicy(new ExitPolicy(closingCharacter));
611           editor.setFinalCaretOffset(offset + 2);
612           editor.enter();
613
614           IRegion newSelection= editor.getSelectedRegion();
615           sourceViewer.setSelectedRange(newSelection.getOffset(), newSelection.getLength());
616         
617           event.doit= false;
618
619         } catch (BadLocationException e) {
620         }
621         break;  
622       }
623     }
624                 
625     /*
626      * @see org.phpeclipse.phpdt.internal.ui.text.link.LinkedPositionUI.ExitListener#exit(boolean)
627      */
628     public void exit(boolean accept) {
629       if (accept)
630         return;
631
632       // remove brackets
633       try {
634         final ISourceViewer sourceViewer= getSourceViewer();
635         IDocument document= sourceViewer.getDocument();
636         document.replace(fOffset, fLength, null);
637       } catch (BadLocationException e) {
638       }
639     }
640
641   }
642   /** The editor's paint manager */
643   private PaintManager fPaintManager;
644   /** The editor's bracket painter */
645   private BracketPainter fBracketPainter;
646   /** The editor's bracket matcher */
647   private PHPPairMatcher fBracketMatcher;
648   /** The editor's line painter */
649   private LinePainter fLinePainter;
650   /** The editor's print margin ruler painter */
651   private PrintMarginPainter fPrintMarginPainter;
652   /** The editor's problem painter */
653   private ProblemPainter fProblemPainter;
654   /** The editor's tab converter */
655   private TabConverter fTabConverter;
656   /** History for structure select action */
657   //private SelectionHistory fSelectionHistory;
658   
659   /** The preference property change listener for php core. */
660   private IPropertyChangeListener fPropertyChangeListener= new PropertyChangeListener();
661   /** The remembered selection */
662   private ITextSelection fRememberedSelection;
663   /** The remembered php element offset */
664   private int fRememberedElementOffset;
665   /** The bracket inserter. */
666   private BracketInserter fBracketInserter= new BracketInserter();
667   
668   private class PropertyChangeListener implements IPropertyChangeListener {             
669     /*
670      * @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)
671      */
672     public void propertyChange(org.eclipse.core.runtime.Preferences.PropertyChangeEvent event) {
673       handlePreferencePropertyChanged(event);
674     }
675   }
676   /* Preference key for code formatter tab size */
677   private final static String CODE_FORMATTER_TAB_SIZE =
678     PHPCore.FORMATTER_TAB_SIZE;
679   /** Preference key for matching brackets */
680   private final static String MATCHING_BRACKETS =
681     PreferenceConstants.EDITOR_MATCHING_BRACKETS;
682   /** Preference key for matching brackets color */
683   private final static String MATCHING_BRACKETS_COLOR =
684     PreferenceConstants.EDITOR_MATCHING_BRACKETS_COLOR;
685   /** Preference key for highlighting current line */
686   private final static String CURRENT_LINE =
687     PreferenceConstants.EDITOR_CURRENT_LINE;
688   /** Preference key for highlight color of current line */
689   private final static String CURRENT_LINE_COLOR =
690     PreferenceConstants.EDITOR_CURRENT_LINE_COLOR;
691   /** Preference key for showing print marging ruler */
692   private final static String PRINT_MARGIN =
693     PreferenceConstants.EDITOR_PRINT_MARGIN;
694   /** Preference key for print margin ruler color */
695   private final static String PRINT_MARGIN_COLOR =
696     PreferenceConstants.EDITOR_PRINT_MARGIN_COLOR;
697   /** Preference key for print margin ruler column */
698   private final static String PRINT_MARGIN_COLUMN =
699     PreferenceConstants.EDITOR_PRINT_MARGIN_COLUMN;
700   /** Preference key for inserting spaces rather than tabs */
701   private final static String SPACES_FOR_TABS =
702     PreferenceConstants.EDITOR_SPACES_FOR_TABS;
703   /** Preference key for error indication */
704   private final static String ERROR_INDICATION =
705     PreferenceConstants.EDITOR_PROBLEM_INDICATION;
706   /** Preference key for error color */
707   private final static String ERROR_INDICATION_COLOR =
708     PreferenceConstants.EDITOR_PROBLEM_INDICATION_COLOR;
709   /** Preference key for warning indication */
710   private final static String WARNING_INDICATION =
711     PreferenceConstants.EDITOR_WARNING_INDICATION;
712   /** Preference key for warning color */
713   private final static String WARNING_INDICATION_COLOR =
714     PreferenceConstants.EDITOR_WARNING_INDICATION_COLOR;
715   /** Preference key for task indication */
716   private final static String TASK_INDICATION =
717     PreferenceConstants.EDITOR_TASK_INDICATION;
718   /** Preference key for task color */
719   private final static String TASK_INDICATION_COLOR =
720     PreferenceConstants.EDITOR_TASK_INDICATION_COLOR;
721   /** Preference key for bookmark indication */
722   private final static String BOOKMARK_INDICATION =
723     PreferenceConstants.EDITOR_BOOKMARK_INDICATION;
724   /** Preference key for bookmark color */
725   private final static String BOOKMARK_INDICATION_COLOR =
726     PreferenceConstants.EDITOR_BOOKMARK_INDICATION_COLOR;
727   /** Preference key for search result indication */
728   private final static String SEARCH_RESULT_INDICATION =
729     PreferenceConstants.EDITOR_SEARCH_RESULT_INDICATION;
730   /** Preference key for search result color */
731   private final static String SEARCH_RESULT_INDICATION_COLOR =
732     PreferenceConstants.EDITOR_SEARCH_RESULT_INDICATION_COLOR;
733   /** Preference key for unknown annotation indication */
734   private final static String UNKNOWN_INDICATION =
735     PreferenceConstants.EDITOR_UNKNOWN_INDICATION;
736   /** Preference key for unknown annotation color */
737   private final static String UNKNOWN_INDICATION_COLOR =
738     PreferenceConstants.EDITOR_UNKNOWN_INDICATION_COLOR;
739   /** Preference key for linked position color */
740   private final static String LINKED_POSITION_COLOR =
741     PreferenceConstants.EDITOR_LINKED_POSITION_COLOR;
742   /** Preference key for shwoing the overview ruler */
743   private final static String OVERVIEW_RULER =
744     PreferenceConstants.EDITOR_OVERVIEW_RULER;
745     
746   /** Preference key for error indication in overview ruler */
747   private final static String ERROR_INDICATION_IN_OVERVIEW_RULER =
748     PreferenceConstants.EDITOR_ERROR_INDICATION_IN_OVERVIEW_RULER;
749   /** Preference key for warning indication in overview ruler */
750   private final static String WARNING_INDICATION_IN_OVERVIEW_RULER =
751     PreferenceConstants.EDITOR_WARNING_INDICATION_IN_OVERVIEW_RULER;
752   /** Preference key for task indication in overview ruler */
753   private final static String TASK_INDICATION_IN_OVERVIEW_RULER =
754     PreferenceConstants.EDITOR_TASK_INDICATION_IN_OVERVIEW_RULER;
755   /** Preference key for bookmark indication in overview ruler */
756   private final static String BOOKMARK_INDICATION_IN_OVERVIEW_RULER =
757     PreferenceConstants.EDITOR_BOOKMARK_INDICATION_IN_OVERVIEW_RULER;
758   /** Preference key for search result indication in overview ruler */
759   private final static String SEARCH_RESULT_INDICATION_IN_OVERVIEW_RULER =
760     PreferenceConstants.EDITOR_SEARCH_RESULT_INDICATION_IN_OVERVIEW_RULER;
761   /** Preference key for unknown annotation indication in overview ruler */
762   private final static String UNKNOWN_INDICATION_IN_OVERVIEW_RULER =
763     PreferenceConstants.EDITOR_UNKNOWN_INDICATION_IN_OVERVIEW_RULER;
764   /** Preference key for automatically closing strings */
765   private final static String CLOSE_STRINGS= PreferenceConstants.EDITOR_CLOSE_STRINGS;
766   /** Preference key for automatically wrapping Java strings */
767   private final static String WRAP_STRINGS= PreferenceConstants.EDITOR_WRAP_STRINGS;
768   /** Preference key for automatically closing brackets and parenthesis */
769   private final static String CLOSE_BRACKETS= PreferenceConstants.EDITOR_CLOSE_BRACKETS;
770   /** Preference key for automatically closing phpdocs and comments */
771   private final static String CLOSE_JAVADOCS= PreferenceConstants.EDITOR_CLOSE_JAVADOCS;
772   /** Preference key for automatically adding phpdoc tags */
773   private final static String ADD_JAVADOC_TAGS= PreferenceConstants.EDITOR_ADD_JAVADOC_TAGS;
774   /** Preference key for automatically formatting phpdocs */
775   private final static String FORMAT_JAVADOCS= PreferenceConstants.EDITOR_FORMAT_JAVADOCS;
776   /** Preference key for smart paste */
777   private final static String SMART_PASTE= PreferenceConstants.EDITOR_SMART_PASTE;
778   private final static class AnnotationInfo {
779     public String fColorPreference;
780     public String fOverviewRulerPreference;
781     public String fEditorPreference;
782   };
783
784   private final static Map ANNOTATION_MAP;
785   static {
786
787     AnnotationInfo info;
788     ANNOTATION_MAP = new HashMap();
789
790     info = new AnnotationInfo();
791     info.fColorPreference = TASK_INDICATION_COLOR;
792     info.fOverviewRulerPreference = TASK_INDICATION_IN_OVERVIEW_RULER;
793     info.fEditorPreference = TASK_INDICATION;
794     ANNOTATION_MAP.put(AnnotationType.TASK, info);
795
796     info = new AnnotationInfo();
797     info.fColorPreference = ERROR_INDICATION_COLOR;
798     info.fOverviewRulerPreference = ERROR_INDICATION_IN_OVERVIEW_RULER;
799     info.fEditorPreference = ERROR_INDICATION;
800     ANNOTATION_MAP.put(AnnotationType.ERROR, info);
801
802     info = new AnnotationInfo();
803     info.fColorPreference = WARNING_INDICATION_COLOR;
804     info.fOverviewRulerPreference = WARNING_INDICATION_IN_OVERVIEW_RULER;
805     info.fEditorPreference = WARNING_INDICATION;
806     ANNOTATION_MAP.put(AnnotationType.WARNING, info);
807
808     info = new AnnotationInfo();
809     info.fColorPreference = BOOKMARK_INDICATION_COLOR;
810     info.fOverviewRulerPreference = BOOKMARK_INDICATION_IN_OVERVIEW_RULER;
811     info.fEditorPreference = BOOKMARK_INDICATION;
812     ANNOTATION_MAP.put(AnnotationType.BOOKMARK, info);
813
814     info = new AnnotationInfo();
815     info.fColorPreference = SEARCH_RESULT_INDICATION_COLOR;
816     info.fOverviewRulerPreference = SEARCH_RESULT_INDICATION_IN_OVERVIEW_RULER;
817     info.fEditorPreference = SEARCH_RESULT_INDICATION;
818     ANNOTATION_MAP.put(AnnotationType.SEARCH_RESULT, info);
819
820     info = new AnnotationInfo();
821     info.fColorPreference = UNKNOWN_INDICATION_COLOR;
822     info.fOverviewRulerPreference = UNKNOWN_INDICATION_IN_OVERVIEW_RULER;
823     info.fEditorPreference = UNKNOWN_INDICATION;
824     ANNOTATION_MAP.put(AnnotationType.UNKNOWN, info);
825   };
826
827   private final static AnnotationType[] ANNOTATION_LAYERS =
828     new AnnotationType[] {
829       AnnotationType.UNKNOWN,
830       AnnotationType.BOOKMARK,
831       AnnotationType.TASK,
832       AnnotationType.SEARCH_RESULT,
833       AnnotationType.WARNING,
834       AnnotationType.ERROR };
835
836   /**
837    * Creates a new php unit editor.
838    */
839   public PHPUnitEditor() {
840     super();
841     setDocumentProvider(PHPeclipsePlugin.getDefault().getCompilationUnitDocumentProvider());
842     setEditorContextMenuId("#PHPEditorContext"); //$NON-NLS-1$
843     setRulerContextMenuId("#PHPRulerContext"); //$NON-NLS-1$
844     
845   }
846   
847   public void createPartControl(Composite parent) {
848     super.createPartControl(parent);
849
850     fPaintManager = new PaintManager(getSourceViewer());
851
852     LinePainter linePainter;
853     linePainter = new LinePainter(getSourceViewer());
854
855     linePainter.setHighlightColor(
856       new Color(Display.getCurrent(), 225, 235, 224));
857
858     fPaintManager.addPainter(linePainter);
859
860                 
861     if (isBracketHighlightingEnabled())
862       startBracketHighlighting();
863     if (isLineHighlightingEnabled())
864       startLineHighlighting();
865     if (isPrintMarginVisible())
866       showPrintMargin();
867                 
868                 
869     Iterator e= ANNOTATION_MAP.keySet().iterator();
870     while (e.hasNext()) {
871       AnnotationType type= (AnnotationType) e.next();
872       if (isAnnotationIndicationEnabled(type))
873         startAnnotationIndication(type);
874     }
875                         
876     if (isTabConversionEnabled())
877       startTabConversion();
878
879     if (isOverviewRulerVisible())
880       showOverviewRuler();
881                         
882                         
883     Preferences preferences= PHPeclipsePlugin.getDefault().getPluginPreferences();
884     preferences.addPropertyChangeListener(fPropertyChangeListener);                     
885                 
886     IPreferenceStore preferenceStore= getPreferenceStore();
887     boolean closeBrackets= preferenceStore.getBoolean(CLOSE_BRACKETS);
888     boolean closeStrings= preferenceStore.getBoolean(CLOSE_STRINGS);
889                 
890     fBracketInserter.setCloseBracketsEnabled(closeBrackets);
891     fBracketInserter.setCloseStringsEnabled(closeStrings);
892                 
893     ISourceViewer sourceViewer= getSourceViewer();
894     if (sourceViewer instanceof ITextViewerExtension)
895       ((ITextViewerExtension) sourceViewer).prependVerifyKeyListener(fBracketInserter);
896
897   }
898
899   private static char getPeerCharacter(char character) {
900     switch (character) {
901       case '(':
902         return ')';
903                                 
904       case ')':
905         return '(';
906                                 
907       case '[':
908         return ']';
909
910       case ']':
911         return '[';
912                                 
913       case '"':
914         return character;
915                         
916       default:
917         throw new IllegalArgumentException();
918     }                                   
919   }
920         
921   /*
922    * @see AbstractTextEditor#doSetInput(IEditorInput)
923    */
924   protected void doSetInput(IEditorInput input) throws CoreException {
925     super.doSetInput(input);
926     configureTabConverter();
927   }
928
929   private void startBracketHighlighting() {
930     if (fBracketPainter == null) {
931       ISourceViewer sourceViewer = getSourceViewer();
932       fBracketPainter = new BracketPainter(sourceViewer);
933       fBracketPainter.setHighlightColor(getColor(MATCHING_BRACKETS_COLOR));
934       fPaintManager.addPainter(fBracketPainter);
935     }
936   }
937
938   private void stopBracketHighlighting() {
939     if (fBracketPainter != null) {
940       fPaintManager.removePainter(fBracketPainter);
941       fBracketPainter.deactivate(true);
942       fBracketPainter.dispose();
943       fBracketPainter = null;
944     }
945   }
946
947   private boolean isBracketHighlightingEnabled() {
948     IPreferenceStore store = getPreferenceStore();
949     return store.getBoolean(MATCHING_BRACKETS);
950   }
951
952   private void startLineHighlighting() {
953     if (fLinePainter == null) {
954       ISourceViewer sourceViewer = getSourceViewer();
955       fLinePainter = new LinePainter(sourceViewer);
956       fLinePainter.setHighlightColor(getColor(CURRENT_LINE_COLOR));
957       fPaintManager.addPainter(fLinePainter);
958     }
959   }
960
961   private void stopLineHighlighting() {
962     if (fLinePainter != null) {
963       fPaintManager.removePainter(fLinePainter);
964       fLinePainter.deactivate(true);
965       fLinePainter.dispose();
966       fLinePainter = null;
967     }
968   }
969
970   private boolean isLineHighlightingEnabled() {
971     IPreferenceStore store = getPreferenceStore();
972     return store.getBoolean(CURRENT_LINE);
973   }
974
975   private void showPrintMargin() {
976     if (fPrintMarginPainter == null) {
977       fPrintMarginPainter = new PrintMarginPainter(getSourceViewer());
978       fPrintMarginPainter.setMarginRulerColor(getColor(PRINT_MARGIN_COLOR));
979       fPrintMarginPainter.setMarginRulerColumn(
980         getPreferenceStore().getInt(PRINT_MARGIN_COLUMN));
981       fPaintManager.addPainter(fPrintMarginPainter);
982     }
983   }
984
985   private void hidePrintMargin() {
986     if (fPrintMarginPainter != null) {
987       fPaintManager.removePainter(fPrintMarginPainter);
988       fPrintMarginPainter.deactivate(true);
989       fPrintMarginPainter.dispose();
990       fPrintMarginPainter = null;
991     }
992   }
993
994   private boolean isPrintMarginVisible() {
995     IPreferenceStore store = getPreferenceStore();
996     return store.getBoolean(PRINT_MARGIN);
997   }
998
999   private void startAnnotationIndication(AnnotationType annotationType) {
1000     if (fProblemPainter == null) {
1001       fProblemPainter = new ProblemPainter(this, getSourceViewer());
1002       fPaintManager.addPainter(fProblemPainter);
1003     }
1004     fProblemPainter.setColor(annotationType, getColor(annotationType));
1005     fProblemPainter.paintAnnotations(annotationType, true);
1006     fProblemPainter.paint(IPainter.CONFIGURATION);
1007   }
1008
1009   private void shutdownAnnotationIndication() {
1010     if (fProblemPainter != null) {
1011
1012       if (!fProblemPainter.isPaintingAnnotations()) {
1013         fPaintManager.removePainter(fProblemPainter);
1014         fProblemPainter.deactivate(true);
1015         fProblemPainter.dispose();
1016         fProblemPainter = null;
1017       } else {
1018         fProblemPainter.paint(IPainter.CONFIGURATION);
1019       }
1020     }
1021   }
1022
1023   private void stopAnnotationIndication(AnnotationType annotationType) {
1024     if (fProblemPainter != null) {
1025       fProblemPainter.paintAnnotations(annotationType, false);
1026       shutdownAnnotationIndication();
1027     }
1028   }
1029
1030   private boolean isAnnotationIndicationEnabled(AnnotationType annotationType) {
1031     IPreferenceStore store = getPreferenceStore();
1032     AnnotationInfo info = (AnnotationInfo) ANNOTATION_MAP.get(annotationType);
1033     if (info != null)
1034       return store.getBoolean(info.fEditorPreference);
1035     return false;
1036   }
1037
1038   private boolean isAnnotationIndicationInOverviewRulerEnabled(AnnotationType annotationType) {
1039     IPreferenceStore store = getPreferenceStore();
1040     AnnotationInfo info = (AnnotationInfo) ANNOTATION_MAP.get(annotationType);
1041     if (info != null)
1042       return store.getBoolean(info.fOverviewRulerPreference);
1043     return false;
1044   }
1045
1046   private void showAnnotationIndicationInOverviewRuler(
1047     AnnotationType annotationType,
1048     boolean show) {
1049     AdaptedSourceViewer asv = (AdaptedSourceViewer) getSourceViewer();
1050     OverviewRuler ruler = asv.getOverviewRuler();
1051     if (ruler != null) {
1052       ruler.setColor(annotationType, getColor(annotationType));
1053       ruler.showAnnotation(annotationType, show);
1054       ruler.update();
1055     }
1056   }
1057
1058   private void setColorInOverviewRuler(
1059     AnnotationType annotationType,
1060     Color color) {
1061     AdaptedSourceViewer asv = (AdaptedSourceViewer) getSourceViewer();
1062     OverviewRuler ruler = asv.getOverviewRuler();
1063     if (ruler != null) {
1064       ruler.setColor(annotationType, color);
1065       ruler.update();
1066     }
1067   }
1068
1069   private void configureTabConverter() {
1070     if (fTabConverter != null) {
1071       IDocumentProvider provider = getDocumentProvider();
1072       if (provider instanceof PHPDocumentProvider) {
1073         PHPDocumentProvider cup = (PHPDocumentProvider) provider;
1074         fTabConverter.setLineTracker(cup.createLineTracker(getEditorInput()));
1075       }
1076     }
1077   }
1078
1079   private int getTabSize() {
1080     Preferences preferences =
1081       PHPeclipsePlugin.getDefault().getPluginPreferences();
1082     return preferences.getInt(CODE_FORMATTER_TAB_SIZE);
1083   }
1084
1085   private void startTabConversion() {
1086     if (fTabConverter == null) {
1087       fTabConverter = new TabConverter();
1088       configureTabConverter();
1089       fTabConverter.setNumberOfSpacesPerTab(getTabSize());
1090       AdaptedSourceViewer asv = (AdaptedSourceViewer) getSourceViewer();
1091       asv.addTextConverter(fTabConverter);
1092       // http://dev.eclipse.org/bugs/show_bug.cgi?id=19270
1093       asv.updateIndentationPrefixes();
1094     }
1095   }
1096
1097   private void stopTabConversion() {
1098     if (fTabConverter != null) {
1099       AdaptedSourceViewer asv = (AdaptedSourceViewer) getSourceViewer();
1100       asv.removeTextConverter(fTabConverter);
1101       // http://dev.eclipse.org/bugs/show_bug.cgi?id=19270
1102       asv.updateIndentationPrefixes();
1103       fTabConverter = null;
1104     }
1105   }
1106
1107   private boolean isTabConversionEnabled() {
1108     IPreferenceStore store = getPreferenceStore();
1109     return store.getBoolean(SPACES_FOR_TABS);
1110   }
1111
1112   private void showOverviewRuler() {
1113     AdaptedSourceViewer asv = (AdaptedSourceViewer) getSourceViewer();
1114     asv.showOverviewRuler();
1115
1116     OverviewRuler overviewRuler = asv.getOverviewRuler();
1117     if (overviewRuler != null) {
1118       for (int i = 0; i < ANNOTATION_LAYERS.length; i++) {
1119         AnnotationType type = ANNOTATION_LAYERS[i];
1120         overviewRuler.setLayer(type, i);
1121         if (isAnnotationIndicationInOverviewRulerEnabled(type))
1122           showAnnotationIndicationInOverviewRuler(type, true);
1123       }
1124     }
1125   }
1126
1127   private void hideOverviewRuler() {
1128     AdaptedSourceViewer asv = (AdaptedSourceViewer) getSourceViewer();
1129     asv.hideOverviewRuler();
1130   }
1131
1132   private boolean isOverviewRulerVisible() {
1133     IPreferenceStore store = getPreferenceStore();
1134     return store.getBoolean(OVERVIEW_RULER);
1135   }
1136
1137   private Color getColor(String key) {
1138     RGB rgb = PreferenceConverter.getColor(getPreferenceStore(), key);
1139     return getColor(rgb);
1140   }
1141
1142   private Color getColor(RGB rgb) {
1143     JavaTextTools textTools = PHPeclipsePlugin.getDefault().getJavaTextTools();
1144     return textTools.getColorManager().getColor(rgb);
1145   }
1146
1147   private Color getColor(AnnotationType annotationType) {
1148     AnnotationInfo info = (AnnotationInfo) ANNOTATION_MAP.get(annotationType);
1149     if (info != null)
1150       return getColor(info.fColorPreference);
1151     return null;
1152   }
1153
1154   public void dispose() {
1155     ISourceViewer sourceViewer= getSourceViewer();
1156     if (sourceViewer instanceof ITextViewerExtension)
1157       ((ITextViewerExtension) sourceViewer).removeVerifyKeyListener(fBracketInserter);
1158       
1159     if (fPropertyChangeListener != null) {
1160       Preferences preferences= PHPeclipsePlugin.getDefault().getPluginPreferences();
1161       preferences.removePropertyChangeListener(fPropertyChangeListener);
1162       fPropertyChangeListener= null;
1163     }
1164     
1165                 
1166 //    if (fJavaEditorErrorTickUpdater != null) {
1167 //      fJavaEditorErrorTickUpdater.dispose();
1168 //      fJavaEditorErrorTickUpdater= null;
1169 //    }
1170 //              
1171 //    if (fSelectionHistory != null)
1172 //      fSelectionHistory.dispose();
1173       
1174     if (fPaintManager != null) {
1175       fPaintManager.dispose();
1176       fPaintManager = null;
1177     }
1178
1179     if (fActionGroups != null)
1180       fActionGroups.dispose();
1181       
1182     super.dispose();
1183   }
1184   
1185   protected AnnotationType getAnnotationType(String preferenceKey) {
1186     Iterator e= ANNOTATION_MAP.keySet().iterator();
1187     while (e.hasNext()) {
1188       AnnotationType type= (AnnotationType) e.next();
1189       AnnotationInfo info= (AnnotationInfo) ANNOTATION_MAP.get(type);
1190       if (info != null) {
1191         if (preferenceKey.equals(info.fColorPreference) || preferenceKey.equals(info.fEditorPreference) || preferenceKey.equals(info.fOverviewRulerPreference)) 
1192           return type;
1193       }
1194     }
1195     return null;
1196   }
1197   
1198   /*
1199    * @see AbstractTextEditor#handlePreferenceStoreChanged(PropertyChangeEvent)
1200    */
1201   protected void handlePreferenceStoreChanged(PropertyChangeEvent event) {
1202                 
1203     try {
1204                         
1205       AdaptedSourceViewer asv= (AdaptedSourceViewer) getSourceViewer();
1206       if (asv != null) {
1207                                         
1208         String p= event.getProperty();          
1209                                 
1210         if (CLOSE_BRACKETS.equals(p)) {
1211           fBracketInserter.setCloseBracketsEnabled(getPreferenceStore().getBoolean(p));
1212           return;       
1213         }
1214
1215         if (CLOSE_STRINGS.equals(p)) {
1216           fBracketInserter.setCloseStringsEnabled(getPreferenceStore().getBoolean(p));
1217           return;
1218         }
1219                                                                 
1220         if (SPACES_FOR_TABS.equals(p)) {
1221           if (isTabConversionEnabled())
1222             startTabConversion();
1223           else
1224             stopTabConversion();
1225           return;
1226         }
1227                                 
1228         if (MATCHING_BRACKETS.equals(p)) {
1229           if (isBracketHighlightingEnabled())
1230             startBracketHighlighting();
1231           else
1232             stopBracketHighlighting();
1233           return;
1234         }
1235                                 
1236         if (MATCHING_BRACKETS_COLOR.equals(p)) {
1237           if (fBracketPainter != null)
1238             fBracketPainter.setHighlightColor(getColor(MATCHING_BRACKETS_COLOR));
1239           return;
1240         }
1241                                 
1242         if (CURRENT_LINE.equals(p)) {
1243           if (isLineHighlightingEnabled())
1244             startLineHighlighting();
1245           else
1246             stopLineHighlighting();
1247           return;
1248         }
1249                                 
1250         if (CURRENT_LINE_COLOR.equals(p)) {
1251           if (fLinePainter != null) {
1252             stopLineHighlighting();
1253             startLineHighlighting();
1254           }                                     
1255           return;
1256         }
1257                                 
1258         if (PRINT_MARGIN.equals(p)) {
1259           if (isPrintMarginVisible())
1260             showPrintMargin();
1261           else
1262             hidePrintMargin();
1263           return;
1264         }
1265                                 
1266         if (PRINT_MARGIN_COLOR.equals(p)) {
1267           if (fPrintMarginPainter != null)
1268             fPrintMarginPainter.setMarginRulerColor(getColor(PRINT_MARGIN_COLOR));
1269           return;
1270         }
1271                                 
1272         if (PRINT_MARGIN_COLUMN.equals(p)) {
1273           if (fPrintMarginPainter != null)
1274             fPrintMarginPainter.setMarginRulerColumn(getPreferenceStore().getInt(PRINT_MARGIN_COLUMN));
1275           return;
1276         }
1277                                 
1278         if (OVERVIEW_RULER.equals(p))  {
1279           if (isOverviewRulerVisible())
1280             showOverviewRuler();
1281           else
1282             hideOverviewRuler();
1283           return;
1284         }
1285                                 
1286         AnnotationType type= getAnnotationType(p);
1287         if (type != null) {
1288                                         
1289           AnnotationInfo info= (AnnotationInfo) ANNOTATION_MAP.get(type);
1290           if (info.fColorPreference.equals(p)) {
1291             Color color= getColor(type);
1292             if (fProblemPainter != null) {
1293               fProblemPainter.setColor(type, color);
1294               fProblemPainter.paint(IPainter.CONFIGURATION);
1295             }
1296             setColorInOverviewRuler(type, color);
1297             return;
1298           }
1299                                         
1300           if (info.fEditorPreference.equals(p)) {
1301             if (isAnnotationIndicationEnabled(type))
1302               startAnnotationIndication(type);
1303             else
1304               stopAnnotationIndication(type);
1305             return;
1306           }
1307                                         
1308           if (info.fOverviewRulerPreference.equals(p)) {
1309             if (isAnnotationIndicationInOverviewRulerEnabled(type))
1310               showAnnotationIndicationInOverviewRuler(type, true);
1311             else
1312               showAnnotationIndicationInOverviewRuler(type, false);
1313             return;
1314           }
1315         }
1316
1317         IContentAssistant c= asv.getContentAssistant();
1318         if (c instanceof ContentAssistant)
1319           ContentAssistPreference.changeConfiguration((ContentAssistant) c, getPreferenceStore(), event);
1320       }
1321                                 
1322     } finally {
1323       super.handlePreferenceStoreChanged(event);
1324     }
1325   }
1326
1327   /**
1328    * Handles a property change event describing a change
1329    * of the php core's preferences and updates the preference
1330    * related editor properties.
1331    * 
1332    * @param event the property change event
1333    */
1334   protected void handlePreferencePropertyChanged(org.eclipse.core.runtime.Preferences.PropertyChangeEvent event) {
1335     AdaptedSourceViewer asv= (AdaptedSourceViewer) getSourceViewer();
1336     if (asv != null) {
1337       String p= event.getProperty();                                    
1338       if (CODE_FORMATTER_TAB_SIZE.equals(p)) {
1339         asv.updateIndentationPrefixes();
1340         if (fTabConverter != null)
1341           fTabConverter.setNumberOfSpacesPerTab(getTabSize());
1342       }
1343     }
1344   }
1345   
1346   /*
1347    * @see PHPEditor#createJavaSourceViewer(Composite, IVerticalRuler, int)
1348    */
1349   protected ISourceViewer createJavaSourceViewer(Composite parent, IVerticalRuler ruler, int styles) {
1350     return new AdaptedSourceViewer(parent, ruler, styles);
1351   }
1352  
1353   private boolean isValidSelection(int offset, int length) {
1354     IDocumentProvider provider= getDocumentProvider();
1355     if (provider != null) {
1356       IDocument document= provider.getDocument(getEditorInput());
1357       if (document != null) {
1358         int end= offset + length;
1359         int documentLength= document.getLength();
1360         return 0 <= offset  && offset <= documentLength && 0 <= end && end <= documentLength;
1361       }
1362     }
1363     return false;
1364   }
1365         
1366   /*
1367    * @see AbstractTextEditor#canHandleMove(IEditorInput, IEditorInput)
1368    */
1369   protected boolean canHandleMove(IEditorInput originalElement, IEditorInput movedElement) {
1370                 
1371     String oldExtension= ""; //$NON-NLS-1$
1372     if (originalElement instanceof IFileEditorInput) {
1373       IFile file= ((IFileEditorInput) originalElement).getFile();
1374       if (file != null) {
1375         String ext= file.getFileExtension();
1376         if (ext != null)
1377           oldExtension= ext;
1378       }
1379     }
1380                 
1381     String newExtension= ""; //$NON-NLS-1$
1382     if (movedElement instanceof IFileEditorInput) {
1383       IFile file= ((IFileEditorInput) movedElement).getFile();
1384       if (file != null)
1385         newExtension= file.getFileExtension();
1386     }
1387                 
1388     return oldExtension.equals(newExtension);
1389   } 
1390 }