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