Some minor changes
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / phpeditor / PHPDocumentProvider.java
1 package net.sourceforge.phpeclipse.phpeditor;
2
3 /**********************************************************************
4 Copyright (c) 2000, 2002 IBM Corp. and others.
5 All rights reserved. This program and the accompanying materials
6 are made available under the terms of the Common Public License v1.0
7 which accompanies this distribution, and is available at
8 http://www.eclipse.org/legal/cpl-v10.html
9
10 Contributors:
11     IBM Corporation - Initial implementation
12     Klaus Hartlage - www.eclipseproject.de
13 **********************************************************************/
14
15 import java.util.ArrayList;
16 import java.util.Iterator;
17 import java.util.List;
18
19 import net.sourceforge.phpdt.core.IProblemRequestor;
20 import net.sourceforge.phpdt.core.compiler.IProblem;
21 import net.sourceforge.phpdt.internal.ui.text.java.IProblemRequestorExtension;
22 import net.sourceforge.phpeclipse.phpeditor.php.IPHPPartitionScannerConstants;
23 import net.sourceforge.phpeclipse.phpeditor.php.PHPPartitionScanner;
24
25 import org.eclipse.core.resources.IFile;
26 import org.eclipse.core.resources.IMarker;
27 import org.eclipse.core.resources.IMarkerDelta;
28 import org.eclipse.core.runtime.CoreException;
29 import org.eclipse.core.runtime.IProgressMonitor;
30 import org.eclipse.jface.text.DefaultLineTracker;
31 import org.eclipse.jface.text.IDocument;
32 import org.eclipse.jface.text.IDocumentPartitioner;
33 import org.eclipse.jface.text.ILineTracker;
34 import org.eclipse.jface.text.Position;
35 import org.eclipse.jface.text.rules.DefaultPartitioner;
36 import org.eclipse.jface.text.source.Annotation;
37 import org.eclipse.jface.text.source.AnnotationModelEvent;
38 import org.eclipse.jface.text.source.IAnnotationModel;
39 import org.eclipse.jface.text.source.IAnnotationModelListener;
40 import org.eclipse.jface.text.source.IAnnotationModelListenerExtension;
41 import org.eclipse.jface.util.ListenerList;
42 import org.eclipse.ui.IFileEditorInput;
43 import org.eclipse.ui.editors.text.FileDocumentProvider;
44 import org.eclipse.ui.part.FileEditorInput;
45 import org.eclipse.ui.texteditor.MarkerAnnotation;
46 import org.eclipse.ui.texteditor.ResourceMarkerAnnotationModel;
47
48 /** 
49  * The PHPDocumentProvider provides the IDocuments used by java editors.
50  */
51
52 public class PHPDocumentProvider extends FileDocumentProvider {
53
54   // private final static String[] TYPES= new String[] { PHPPartitionScanner.PHP, PHPPartitionScanner.JAVA_DOC, PHPPartitionScanner.JAVA_MULTILINE_COMMENT };
55   private final static String[] TYPES =
56     new String[] {
57       IPHPPartitionScannerConstants.PHP,
58       IPHPPartitionScannerConstants.PHP_MULTILINE_COMMENT,
59       IPHPPartitionScannerConstants.HTML,
60       IPHPPartitionScannerConstants.HTML_MULTILINE_COMMENT,
61       IPHPPartitionScannerConstants.JAVASCRIPT,
62       IPHPPartitionScannerConstants.CSS,
63                         IPHPPartitionScannerConstants.SMARTY,
64                         IPHPPartitionScannerConstants.SMARTY_MULTILINE_COMMENT };
65
66   private static PHPPartitionScanner PHP_PARTITION_SCANNER = null;
67   private static PHPPartitionScanner HTML_PARTITION_SCANNER = null;
68   private static PHPPartitionScanner XML_PARTITION_SCANNER = null;
69   private static PHPPartitionScanner SMARTY_PARTITION_SCANNER = null;
70
71   /** annotation model listener added to all created CU annotation models */
72   //            private GlobalAnnotationModelListener fGlobalAnnotationModelListener;   
73
74   /**
75                  * Internal structure for mapping positions to some value. 
76                  * The reason for this specific structure is that positions can
77                  * change over time. Thus a lookup is based on value and not
78                  * on hash value.
79                  */
80   protected static class ReverseMap {
81
82     static class Entry {
83       Position fPosition;
84       Object fValue;
85     };
86
87     private List fList = new ArrayList(2);
88     private int fAnchor = 0;
89
90     public ReverseMap() {
91     }
92
93     public Object get(Position position) {
94
95       Entry entry;
96
97       // behind anchor
98       int length = fList.size();
99       for (int i = fAnchor; i < length; i++) {
100         entry = (Entry) fList.get(i);
101         if (entry.fPosition.equals(position)) {
102           fAnchor = i;
103           return entry.fValue;
104         }
105       }
106
107       // before anchor
108       for (int i = 0; i < fAnchor; i++) {
109         entry = (Entry) fList.get(i);
110         if (entry.fPosition.equals(position)) {
111           fAnchor = i;
112           return entry.fValue;
113         }
114       }
115
116       return null;
117     }
118
119     private int getIndex(Position position) {
120       Entry entry;
121       int length = fList.size();
122       for (int i = 0; i < length; i++) {
123         entry = (Entry) fList.get(i);
124         if (entry.fPosition.equals(position))
125           return i;
126       }
127       return -1;
128     }
129
130     public void put(Position position, Object value) {
131       int index = getIndex(position);
132       if (index == -1) {
133         Entry entry = new Entry();
134         entry.fPosition = position;
135         entry.fValue = value;
136         fList.add(entry);
137       } else {
138         Entry entry = (Entry) fList.get(index);
139         entry.fValue = value;
140       }
141     }
142
143     public void remove(Position position) {
144       int index = getIndex(position);
145       if (index > -1)
146         fList.remove(index);
147     }
148
149     public void clear() {
150       fList.clear();
151     }
152   };
153
154   /**
155                  * Annotation model dealing with java marker annotations and temporary problems.
156                  * Also acts as problem requestor for its compilation unit. Initialiy inactive. Must explicitly be
157                  * activated.
158                  */
159   protected class CompilationUnitAnnotationModel
160     extends ResourceMarkerAnnotationModel
161     implements IProblemRequestor, IProblemRequestorExtension {
162
163     private IFileEditorInput fInput;
164     private List fCollectedProblems;
165     private List fGeneratedAnnotations;
166     private IProgressMonitor fProgressMonitor;
167     private boolean fIsActive = false;
168
169     private ReverseMap fReverseMap = new ReverseMap();
170     private List fPreviouslyOverlaid = null;
171     private List fCurrentlyOverlaid = new ArrayList();
172
173     public CompilationUnitAnnotationModel(IFileEditorInput input) {
174       super(input.getFile());
175       fInput = input;
176     }
177
178     protected MarkerAnnotation createMarkerAnnotation(IMarker marker) {
179       return new JavaMarkerAnnotation(marker);
180     }
181
182     protected Position createPositionFromProblem(IProblem problem) {
183       int start = problem.getSourceStart();
184       if (start < 0)
185         return null;
186
187       int length = problem.getSourceEnd() - problem.getSourceStart() + 1;
188       if (length < 0)
189         return null;
190
191       return new Position(start, length);
192     }
193
194     protected void update(IMarkerDelta[] markerDeltas) {
195
196       super.update(markerDeltas);
197
198       //                                        if (markerDeltas != null && markerDeltas.length > 0) {
199       //                                                try {
200       //                                                        ICompilationUnit workingCopy = getWorkingCopy(fInput);
201       //                                                        if (workingCopy != null)
202       //                                                                workingCopy.reconcile(true, null);
203       //                                                } catch (JavaModelException ex) {
204       //                                                        handleCoreException(ex, ex.getMessage());
205       //                                                }
206       //                                        }
207     }
208
209     /*
210      * @see IProblemRequestor#beginReporting()
211      */
212     public void beginReporting() {
213       //                                        ICompilationUnit unit= getWorkingCopy(fInput);
214       //                                        if (unit != null && unit.getJavaProject().isOnClasspath(unit))
215       //                                                fCollectedProblems= new ArrayList();
216       //                                        else
217       fCollectedProblems = null;
218     }
219
220     /*
221      * @see IProblemRequestor#acceptProblem(IProblem)
222      */
223     public void acceptProblem(IProblem problem) {
224       if (isActive())
225         fCollectedProblems.add(problem);
226     }
227
228     /*
229      * @see IProblemRequestor#endReporting()
230      */
231     public void endReporting() {
232       if (!isActive())
233         return;
234
235       if (fProgressMonitor != null && fProgressMonitor.isCanceled())
236         return;
237
238       boolean isCanceled = false;
239       boolean temporaryProblemsChanged = false;
240       fPreviouslyOverlaid = fCurrentlyOverlaid;
241       fCurrentlyOverlaid = new ArrayList();
242
243       synchronized (fAnnotations) {
244
245         if (fGeneratedAnnotations.size() > 0) {
246           temporaryProblemsChanged = true;
247           removeAnnotations(fGeneratedAnnotations, false, true);
248           fGeneratedAnnotations.clear();
249         }
250
251         if (fCollectedProblems != null && fCollectedProblems.size() > 0) {
252
253           Iterator e = fCollectedProblems.iterator();
254           while (e.hasNext()) {
255
256             IProblem problem = (IProblem) e.next();
257
258             if (fProgressMonitor != null && fProgressMonitor.isCanceled()) {
259               isCanceled = true;
260               break;
261             }
262
263             Position position = createPositionFromProblem(problem);
264             if (position != null) {
265
266               //                                                                        ProblemAnnotation annotation= new ProblemAnnotation(problem);
267               //                                                                        overlayMarkers(position, annotation);                                                           
268               //                                                                        fGeneratedAnnotations.add(annotation);
269               //                                                                        addAnnotation(annotation, position, false);
270
271               temporaryProblemsChanged = true;
272             }
273           }
274
275           fCollectedProblems.clear();
276         }
277
278         removeMarkerOverlays(isCanceled);
279         fPreviouslyOverlaid.clear();
280         fPreviouslyOverlaid = null;
281       }
282
283       //                                        if (temporaryProblemsChanged)
284       //                                                fireModelChanged(new CompilationUnitAnnotationModelEvent(this, getResource(), false));
285     }
286
287     private void removeMarkerOverlays(boolean isCanceled) {
288       if (isCanceled) {
289         fCurrentlyOverlaid.addAll(fPreviouslyOverlaid);
290       } else if (fPreviouslyOverlaid != null) {
291         Iterator e = fPreviouslyOverlaid.iterator();
292         while (e.hasNext()) {
293           JavaMarkerAnnotation annotation = (JavaMarkerAnnotation) e.next();
294           annotation.setOverlay(null);
295         }
296       }
297     }
298
299     /**
300      * Overlays value with problem annotation.
301      * @param problemAnnotation
302      */
303     //                          private void setOverlay(Object value, ProblemAnnotation problemAnnotation) {
304     //                                  if (value instanceof  JavaMarkerAnnotation) {
305     //                                          JavaMarkerAnnotation annotation= (JavaMarkerAnnotation) value;
306     //                                          if (annotation.isProblem()) {
307     //                                                  annotation.setOverlay(problemAnnotation);
308     //                                                  fPreviouslyOverlaid.remove(annotation);
309     //                                                  fCurrentlyOverlaid.add(annotation);
310     //                                          }
311     //                                  }
312     //                          }
313
314     //                          private void  overlayMarkers(Position position, ProblemAnnotation problemAnnotation) {
315     //                                  Object value= getAnnotations(position);
316     //                                  if (value instanceof List) {
317     //                                          List list= (List) value;
318     //                                          for (Iterator e = list.iterator(); e.hasNext();)
319     //                                                  setOverlay(e.next(), problemAnnotation);
320     //                                  } else {
321     //                                          setOverlay(value, problemAnnotation);
322     //                                  }
323     //                          }
324
325     /**
326      * Tells this annotation model to collect temporary problems from now on.
327      */
328     private void startCollectingProblems() {
329       fCollectedProblems = new ArrayList();
330       fGeneratedAnnotations = new ArrayList();
331     }
332
333     /**
334      * Tells this annotation model to no longer collect temporary problems.
335      */
336     private void stopCollectingProblems() {
337       if (fGeneratedAnnotations != null) {
338         removeAnnotations(fGeneratedAnnotations, true, true);
339         fGeneratedAnnotations.clear();
340       }
341       fCollectedProblems = null;
342       fGeneratedAnnotations = null;
343     }
344
345     /*
346      * @see AnnotationModel#fireModelChanged()
347      */
348     //                          protected void fireModelChanged() {
349     //                                  fireModelChanged(new CompilationUnitAnnotationModelEvent(this, getResource(), true));
350     //                          }
351
352     /*
353      * @see IProblemRequestor#isActive()
354      */
355     public boolean isActive() {
356       return fIsActive && (fCollectedProblems != null);
357     }
358
359     /*
360      * @see IProblemRequestorExtension#setProgressMonitor(IProgressMonitor)
361      */
362     public void setProgressMonitor(IProgressMonitor monitor) {
363       fProgressMonitor = monitor;
364     }
365
366     /*
367      * @see IProblemRequestorExtension#setIsActive(boolean)
368      */
369     public void setIsActive(boolean isActive) {
370       if (fIsActive != isActive) {
371         fIsActive = isActive;
372         if (fIsActive)
373           startCollectingProblems();
374         else
375           stopCollectingProblems();
376       }
377     }
378
379     private Object getAnnotations(Position position) {
380       return fReverseMap.get(position);
381     }
382
383     /*
384      * @see AnnotationModel#addAnnotation(Annotation, Position, boolean)
385      */
386     protected void addAnnotation(Annotation annotation, Position position, boolean fireModelChanged) {
387       super.addAnnotation(annotation, position, fireModelChanged);
388
389       Object cached = fReverseMap.get(position);
390       if (cached == null)
391         fReverseMap.put(position, annotation);
392       else if (cached instanceof List) {
393         List list = (List) cached;
394         list.add(annotation);
395       } else if (cached instanceof Annotation) {
396         List list = new ArrayList(2);
397         list.add(cached);
398         list.add(annotation);
399         fReverseMap.put(position, list);
400       }
401     }
402
403     /*
404      * @see AnnotationModel#removeAllAnnotations(boolean)
405      */
406     protected void removeAllAnnotations(boolean fireModelChanged) {
407       super.removeAllAnnotations(fireModelChanged);
408       fReverseMap.clear();
409     }
410
411     /*
412      * @see AnnotationModel#removeAnnotation(Annotation, boolean)
413      */
414     protected void removeAnnotation(Annotation annotation, boolean fireModelChanged) {
415       Position position = getPosition(annotation);
416       Object cached = fReverseMap.get(position);
417       if (cached instanceof List) {
418         List list = (List) cached;
419         list.remove(annotation);
420         if (list.size() == 1) {
421           fReverseMap.put(position, list.get(0));
422           list.clear();
423         }
424       } else if (cached instanceof Annotation) {
425         fReverseMap.remove(position);
426       }
427
428       super.removeAnnotation(annotation, fireModelChanged);
429     }
430   };
431
432   protected static class GlobalAnnotationModelListener implements IAnnotationModelListener, IAnnotationModelListenerExtension {
433
434     private ListenerList fListenerList;
435
436     public GlobalAnnotationModelListener() {
437       fListenerList = new ListenerList();
438     }
439
440     /**
441      * @see IAnnotationModelListener#modelChanged(IAnnotationModel)
442      */
443     public void modelChanged(IAnnotationModel model) {
444       Object[] listeners = fListenerList.getListeners();
445       for (int i = 0; i < listeners.length; i++) {
446         ((IAnnotationModelListener) listeners[i]).modelChanged(model);
447       }
448     }
449
450     /**
451      * @see IAnnotationModelListenerExtension#modelChanged(AnnotationModelEvent)
452      */
453     public void modelChanged(AnnotationModelEvent event) {
454       Object[] listeners = fListenerList.getListeners();
455       for (int i = 0; i < listeners.length; i++) {
456         Object curr = listeners[i];
457         if (curr instanceof IAnnotationModelListenerExtension) {
458           ((IAnnotationModelListenerExtension) curr).modelChanged(event);
459         }
460       }
461     }
462
463     public void addListener(IAnnotationModelListener listener) {
464       fListenerList.add(listener);
465     }
466
467     public void removeListener(IAnnotationModelListener listener) {
468       fListenerList.remove(listener);
469     }
470   };
471
472   public PHPDocumentProvider() {
473     super();
474
475     //          fGlobalAnnotationModelListener= new GlobalAnnotationModelListener();
476
477   }
478
479   /* (non-Javadoc)
480    * Method declared on AbstractDocumentProvider
481    */
482   protected IDocument createDocument(Object element) throws CoreException {
483     IDocument document = super.createDocument(element);
484     if (document != null) {
485       //  int fileType = 0; // PHP 
486       IDocumentPartitioner partitioner = null;
487       if (element instanceof FileEditorInput) {
488         IFile file = (IFile) ((FileEditorInput) element).getAdapter(IFile.class);
489         String filename = file.getLocation().toString();
490         String extension = filename.substring(filename.lastIndexOf("."), filename.length());
491         //   System.out.println(extension);
492         if (extension.equalsIgnoreCase(".html") || extension.equalsIgnoreCase(".htm")) {
493           // html
494           partitioner = createHTMLPartitioner();
495         } else if (extension.equalsIgnoreCase(".xml")) {
496           // xml
497           partitioner = createXMLPartitioner();
498         } else if (extension.equalsIgnoreCase(".js")) {
499           // javascript
500           partitioner = createJavaScriptPartitioner();
501         } else if (extension.equalsIgnoreCase(".css")) {
502           // cascading style sheets
503           partitioner = createCSSPartitioner();
504         } else if (extension.equalsIgnoreCase(".tpl")) {
505           // smarty ?
506           partitioner = createSmartyPartitioner();
507         } else if (extension.equalsIgnoreCase(".inc")) {
508           // php include files ?
509           partitioner = createIncludePartitioner();
510         }
511       }
512
513       if (partitioner == null) {
514         partitioner = createPHPPartitioner();
515       }
516       document.setDocumentPartitioner(partitioner);
517       partitioner.connect(document);
518     }
519     return document;
520   }
521
522   /**
523    * Return a partitioner for .php files.
524    */
525   private IDocumentPartitioner createPHPPartitioner() {
526     return new DefaultPartitioner(getPHPPartitionScanner(), TYPES);
527   }
528
529   /**
530    * Return a partitioner for .html files.
531    */
532   private IDocumentPartitioner createHTMLPartitioner() {
533     return new DefaultPartitioner(getHTMLPartitionScanner(), TYPES);
534   }
535
536   private IDocumentPartitioner createXMLPartitioner() {
537     return new DefaultPartitioner(getXMLPartitionScanner(), TYPES);
538   }
539
540   private IDocumentPartitioner createJavaScriptPartitioner() {
541     return new DefaultPartitioner(getHTMLPartitionScanner(), TYPES);
542   }
543
544   private IDocumentPartitioner createCSSPartitioner() {
545     return new DefaultPartitioner(getHTMLPartitionScanner(), TYPES);
546   }
547
548   private IDocumentPartitioner createSmartyPartitioner() {
549     return new DefaultPartitioner(getSmartyPartitionScanner(), TYPES);
550   }
551
552   private IDocumentPartitioner createIncludePartitioner() {
553     return new DefaultPartitioner(getPHPPartitionScanner(), TYPES);
554   }
555   /**
556    * Return a scanner for creating php partitions.
557    */
558   private PHPPartitionScanner getPHPPartitionScanner() {
559     if (PHP_PARTITION_SCANNER == null)
560       PHP_PARTITION_SCANNER = new PHPPartitionScanner(IPHPPartitionScannerConstants.PHP_FILE);
561     return PHP_PARTITION_SCANNER;
562   }
563
564   /**
565    * Return a scanner for creating html partitions.
566    */
567   private PHPPartitionScanner getHTMLPartitionScanner() {
568     if (HTML_PARTITION_SCANNER == null)
569       HTML_PARTITION_SCANNER = new PHPPartitionScanner(IPHPPartitionScannerConstants.HTML_FILE);
570     return HTML_PARTITION_SCANNER;
571   }
572
573   /**
574    * Return a scanner for creating xml partitions.
575    */
576   private PHPPartitionScanner getXMLPartitionScanner() {
577     if (XML_PARTITION_SCANNER == null)
578       XML_PARTITION_SCANNER = new PHPPartitionScanner(IPHPPartitionScannerConstants.XML_FILE);
579     return XML_PARTITION_SCANNER;
580   }
581
582   /**
583    * Return a scanner for creating smarty partitions.
584    */
585   private PHPPartitionScanner getSmartyPartitionScanner() {
586     if (SMARTY_PARTITION_SCANNER == null)
587       SMARTY_PARTITION_SCANNER = new PHPPartitionScanner(IPHPPartitionScannerConstants.SMARTY_FILE);
588     return SMARTY_PARTITION_SCANNER;
589   }
590
591   /**
592    * Creates a line tracker working with the same line delimiters as the document
593    * of the given element. Assumes the element to be managed by this document provider.
594    * 
595    * @param element the element serving as blue print
596    * @return a line tracker based on the same line delimiters as the element's document
597    */
598   public ILineTracker createLineTracker(Object element) {
599     return new DefaultLineTracker();
600   }
601 }