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.io.ByteArrayInputStream;
  16 import java.io.IOException;
  17 import java.io.InputStream;
  18 import java.util.ArrayList;
  19 import java.util.Iterator;
  20 import java.util.List;
  21
  22 import net.sourceforge.phpdt.core.IBuffer;
  23 import net.sourceforge.phpdt.core.IBufferFactory;
  24 import net.sourceforge.phpdt.core.ICompilationUnit;
  25 import net.sourceforge.phpdt.core.IJavaModelStatusConstants;
  26 import net.sourceforge.phpdt.core.IOpenable;
  27 import net.sourceforge.phpdt.core.IProblemRequestor;
  28 import net.sourceforge.phpdt.core.JavaModelException;
  29 import net.sourceforge.phpdt.core.compiler.IProblem;
  30 import net.sourceforge.phpdt.internal.ui.PHPStatusConstants;
  31 import net.sourceforge.phpdt.internal.ui.PHPUIStatus;
  32 import net.sourceforge.phpdt.internal.ui.text.java.IProblemRequestorExtension;
  33 import net.sourceforge.phpdt.ui.PreferenceConstants;
  34 import net.sourceforge.phpdt.ui.text.JavaTextTools;
  35 import net.sourceforge.phpeclipse.PHPCore;
  36 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  37
  38 import org.eclipse.core.resources.IFile;
  39 import org.eclipse.core.resources.IMarker;
  40 import org.eclipse.core.resources.IMarkerDelta;
  41 import org.eclipse.core.resources.IResource;
  42 import org.eclipse.core.resources.ResourcesPlugin;
  43 import org.eclipse.core.runtime.CoreException;
  44 import org.eclipse.core.runtime.IProgressMonitor;
  45 import org.eclipse.core.runtime.IStatus;
  46 import org.eclipse.core.runtime.Status;
  47 import org.eclipse.jface.preference.IPreferenceStore;
  48 import org.eclipse.jface.text.BadLocationException;
  49 import org.eclipse.jface.text.DefaultLineTracker;
  50 import org.eclipse.jface.text.Document;
  51 import org.eclipse.jface.text.IDocument;
  52 import org.eclipse.jface.text.IDocumentPartitioner;
  53 import org.eclipse.jface.text.ILineTracker;
  54 import org.eclipse.jface.text.Position;
  55 import org.eclipse.jface.text.source.Annotation;
  56 import org.eclipse.jface.text.source.AnnotationModelEvent;
  57 import org.eclipse.jface.text.source.IAnnotationModel;
  58 import org.eclipse.jface.text.source.IAnnotationModelListener;
  59 import org.eclipse.jface.text.source.IAnnotationModelListenerExtension;
  60 import org.eclipse.jface.util.IPropertyChangeListener;
  61 import org.eclipse.jface.util.ListenerList;
  62 import org.eclipse.jface.util.PropertyChangeEvent;
  63 import org.eclipse.swt.SWT;
  64 import org.eclipse.swt.graphics.GC;
  65 import org.eclipse.swt.graphics.Image;
  66 import org.eclipse.swt.graphics.Rectangle;
  67 import org.eclipse.swt.widgets.Canvas;
  68 import org.eclipse.swt.widgets.Display;
  69 import org.eclipse.ui.IEditorInput;
  70 import org.eclipse.ui.IFileEditorInput;
  71 import org.eclipse.ui.editors.text.FileDocumentProvider;
  72 import org.eclipse.ui.part.FileEditorInput;
  73 import org.eclipse.ui.texteditor.AbstractMarkerAnnotationModel;
  74 import org.eclipse.ui.texteditor.DefaultAnnotation;
  75 import org.eclipse.ui.texteditor.IAnnotationExtension;
  76 import org.eclipse.ui.texteditor.MarkerAnnotation;
  77 import org.eclipse.ui.texteditor.ResourceMarkerAnnotationModel;
  78
  79 /**
  80  * The PHPDocumentProvider provides the IDocuments used by java editors.
  81  */
  82
  83 public class PHPDocumentProvider extends FileDocumentProvider {
  84   /**
  85                          * Here for visibility issues only.
  86                          */
  87   protected class _FileSynchronizer extends FileSynchronizer {
  88     public _FileSynchronizer(IFileEditorInput fileEditorInput) {
  89       super(fileEditorInput);
  90     }
  91   };
  92   /**
  93                  * Bundle of all required informations to allow working copy management.
  94                  */
  95   protected class CompilationUnitInfo extends FileInfo {
  96
  97     ICompilationUnit fCopy;
  98
  99     public CompilationUnitInfo(
 100       IDocument document,
 101       IAnnotationModel model,
 102       _FileSynchronizer fileSynchronizer,
 103       ICompilationUnit copy) {
 104       super(document, model, fileSynchronizer);
 105       fCopy = copy;
 106     }
 107
 108     public void setModificationStamp(long timeStamp) {
 109       fModificationStamp = timeStamp;
 110     }
 111   };
 112   /**
 113                  * Annotation model dealing with java marker annotations and temporary problems.
 114                  * Also acts as problem requestor for its compilation unit. Initialiy inactive. Must explicitly be
 115                  * activated.
 116                  */
 117   protected class CompilationUnitAnnotationModel
 118     extends ResourceMarkerAnnotationModel
 119     implements IProblemRequestor, IProblemRequestorExtension {
 120     private List fCollectedProblems;
 121     private List fCurrentlyOverlaid = new ArrayList();
 122     private List fGeneratedAnnotations;
 123
 124     private IFileEditorInput fInput;
 125     private boolean fIsActive = false;
 126     private List fPreviouslyOverlaid = null;
 127     private IProgressMonitor fProgressMonitor;
 128
 129     private ReverseMap fReverseMap = new ReverseMap();
 130
 131     public CompilationUnitAnnotationModel(IFileEditorInput input) {
 132       super(input.getFile());
 133       fInput = input;
 134     }
 135
 136     /*
 137      * @see IProblemRequestor#acceptProblem(IProblem)
 138      */
 139     public void acceptProblem(IProblem problem) {
 140       if (isActive())
 141         fCollectedProblems.add(problem);
 142     }
 143
 144     /*
 145      * @see AnnotationModel#addAnnotation(Annotation, Position, boolean)
 146      */
 147     protected void addAnnotation(Annotation annotation, Position position, boolean fireModelChanged) throws BadLocationException {
 148       super.addAnnotation(annotation, position, fireModelChanged);
 149
 150       Object cached = fReverseMap.get(position);
 151       if (cached == null)
 152         fReverseMap.put(position, annotation);
 153       else if (cached instanceof List) {
 154         List list = (List) cached;
 155         list.add(annotation);
 156       } else if (cached instanceof Annotation) {
 157         List list = new ArrayList(2);
 158         list.add(cached);
 159         list.add(annotation);
 160         fReverseMap.put(position, list);
 161       }
 162     }
 163
 164     /*
 165      * @see IProblemRequestor#beginReporting()
 166      */
 167     public void beginReporting() {
 168       ICompilationUnit unit = getWorkingCopy(fInput);
 169       if (unit != null) // && unit.getJavaProject().isOnClasspath(unit))
 170         fCollectedProblems = new ArrayList();
 171       else
 172         fCollectedProblems = null;
 173     }
 174
 175     protected MarkerAnnotation createMarkerAnnotation(IMarker marker) {
 176       return new JavaMarkerAnnotation(marker);
 177     }
 178
 179     protected Position createPositionFromProblem(IProblem problem) {
 180       int start = problem.getSourceStart();
 181       if (start < 0)
 182         return null;
 183
 184       int length = problem.getSourceEnd() - problem.getSourceStart() + 1;
 185       if (length < 0)
 186         return null;
 187
 188       return new Position(start, length);
 189     }
 190     /*
 191      * @see IProblemRequestor#endReporting()
 192      */
 193     public void endReporting() {
 194       if (!isActive())
 195         return;
 196
 197       if (fProgressMonitor != null && fProgressMonitor.isCanceled())
 198         return;
 199
 200
 201       boolean isCanceled= false;
 202       boolean temporaryProblemsChanged= false;
 203
 204       synchronized (fAnnotations) {
 205
 206         fPreviouslyOverlaid= fCurrentlyOverlaid;
 207         fCurrentlyOverlaid= new ArrayList();
 208
 209         if (fGeneratedAnnotations.size() > 0) {
 210           temporaryProblemsChanged= true;
 211           removeAnnotations(fGeneratedAnnotations, false, true);
 212           fGeneratedAnnotations.clear();
 213         }
 214
 215         if (fCollectedProblems != null && fCollectedProblems.size() > 0) {
 216
 217           ICompilationUnit cu= getWorkingCopy(fInput);
 218           Iterator e= fCollectedProblems.iterator();
 219           while (e.hasNext()) {
 220
 221             IProblem problem= (IProblem) e.next();
 222
 223             if (fProgressMonitor != null && fProgressMonitor.isCanceled()) {
 224               isCanceled= true;
 225               break;
 226             }
 227
 228             Position position= createPositionFromProblem(problem);
 229             if (position != null) {
 230               try {
 231                 ProblemAnnotation annotation= new ProblemAnnotation(problem, cu);
 232                 addAnnotation(annotation, position, false);
 233                 overlayMarkers(position, annotation);
 234                 fGeneratedAnnotations.add(annotation);
 235
 236                 temporaryProblemsChanged= true;
 237               } catch (BadLocationException x) {
 238                 // ignore invalid position
 239               }
 240             }
 241           }
 242
 243           fCollectedProblems.clear();
 244         }
 245
 246         removeMarkerOverlays(isCanceled);
 247         fPreviouslyOverlaid.clear();
 248         fPreviouslyOverlaid= null;
 249       }
 250
 251       if (temporaryProblemsChanged)
 252         fireModelChanged();
 253     }
 254     /*
 255      * @see IProblemRequestor#endReporting()
 256      */
 257 //    public void endReporting() {
 258 //      if (!isActive())
 259 //        return;
 260 //
 261 //      if (fProgressMonitor != null && fProgressMonitor.isCanceled())
 262 //        return;
 263 //
 264 //      boolean isCanceled = false;
 265 //      boolean temporaryProblemsChanged = false;
 266 //      fPreviouslyOverlaid = fCurrentlyOverlaid;
 267 //      fCurrentlyOverlaid = new ArrayList();
 268 //
 269 //      synchronized (fAnnotations) {
 270 //
 271 //        if (fGeneratedAnnotations.size() > 0) {
 272 //          temporaryProblemsChanged = true;
 273 //          removeAnnotations(fGeneratedAnnotations, false, true);
 274 //          fGeneratedAnnotations.clear();
 275 //        }
 276 //
 277 //        if (fCollectedProblems != null && fCollectedProblems.size() > 0) {
 278 //
 279 //          Iterator e = fCollectedProblems.iterator();
 280 //          while (e.hasNext()) {
 281 //
 282 //            IProblem problem = (IProblem) e.next();
 283 //
 284 //            if (fProgressMonitor != null && fProgressMonitor.isCanceled()) {
 285 //              isCanceled = true;
 286 //              break;
 287 //            }
 288 //
 289 //            Position position = createPositionFromProblem(problem);
 290 //            if (position != null) {
 291 //
 292 //              ProblemAnnotation annotation = new ProblemAnnotation(problem);
 293 //              overlayMarkers(position, annotation);
 294 //              fGeneratedAnnotations.add(annotation);
 295 //              addAnnotation(annotation, position, false);
 296 //
 297 //              temporaryProblemsChanged = true;
 298 //            }
 299 //          }
 300 //
 301 //          fCollectedProblems.clear();
 302 //        }
 303 //
 304 //        removeMarkerOverlays(isCanceled);
 305 //        fPreviouslyOverlaid.clear();
 306 //        fPreviouslyOverlaid = null;
 307 //      }
 308 //
 309 //      if (temporaryProblemsChanged)
 310 //        fireModelChanged(new CompilationUnitAnnotationModelEvent(this, getResource(), false));
 311 //    }
 312
 313     private Object getAnnotations(Position position) {
 314       return fReverseMap.get(position);
 315     }
 316
 317     /*
 318      * @see AnnotationModel#fireModelChanged()
 319      */
 320     protected void fireModelChanged() {
 321       fireModelChanged(new CompilationUnitAnnotationModelEvent(this, getResource(), true));
 322     }
 323
 324     /*
 325      * @see IProblemRequestor#isActive()
 326      */
 327     public boolean isActive() {
 328       return fIsActive && (fCollectedProblems != null);
 329     }
 330
 331     /*
 332      * @see AnnotationModel#removeAllAnnotations(boolean)
 333      */
 334     protected void removeAllAnnotations(boolean fireModelChanged) {
 335       super.removeAllAnnotations(fireModelChanged);
 336       fReverseMap.clear();
 337     }
 338
 339     /*
 340      * @see AnnotationModel#removeAnnotation(Annotation, boolean)
 341      */
 342     protected void removeAnnotation(Annotation annotation, boolean fireModelChanged) {
 343       Position position = getPosition(annotation);
 344       Object cached = fReverseMap.get(position);
 345       if (cached instanceof List) {
 346         List list = (List) cached;
 347         list.remove(annotation);
 348         if (list.size() == 1) {
 349           fReverseMap.put(position, list.get(0));
 350           list.clear();
 351         }
 352       } else if (cached instanceof Annotation) {
 353         fReverseMap.remove(position);
 354       }
 355
 356       super.removeAnnotation(annotation, fireModelChanged);
 357     }
 358
 359     private void removeMarkerOverlays(boolean isCanceled) {
 360       if (isCanceled) {
 361         fCurrentlyOverlaid.addAll(fPreviouslyOverlaid);
 362       } else if (fPreviouslyOverlaid != null) {
 363         Iterator e = fPreviouslyOverlaid.iterator();
 364         while (e.hasNext()) {
 365           JavaMarkerAnnotation annotation = (JavaMarkerAnnotation) e.next();
 366           annotation.setOverlay(null);
 367         }
 368       }
 369     }
 370
 371     /*
 372      * @see IProblemRequestorExtension#setIsActive(boolean)
 373      */
 374     public void setIsActive(boolean isActive) {
 375       if (fIsActive != isActive) {
 376         fIsActive = isActive;
 377         if (fIsActive)
 378           startCollectingProblems();
 379         else
 380           stopCollectingProblems();
 381       }
 382     }
 383
 384     /*
 385      * @see IProblemRequestorExtension#setProgressMonitor(IProgressMonitor)
 386      */
 387     public void setProgressMonitor(IProgressMonitor monitor) {
 388       fProgressMonitor = monitor;
 389     }
 390
 391     /**
 392      * Overlays value with problem annotation.
 393      * @param problemAnnotation
 394      */
 395     private void setOverlay(Object value, ProblemAnnotation problemAnnotation) {
 396       if (value instanceof JavaMarkerAnnotation) {
 397         JavaMarkerAnnotation annotation = (JavaMarkerAnnotation) value;
 398         if (annotation.isProblem()) {
 399           annotation.setOverlay(problemAnnotation);
 400           fPreviouslyOverlaid.remove(annotation);
 401           fCurrentlyOverlaid.add(annotation);
 402         }
 403       }
 404     }
 405
 406     private void overlayMarkers(Position position, ProblemAnnotation problemAnnotation) {
 407       Object value = getAnnotations(position);
 408       if (value instanceof List) {
 409         List list = (List) value;
 410         for (Iterator e = list.iterator(); e.hasNext();)
 411           setOverlay(e.next(), problemAnnotation);
 412       } else {
 413         setOverlay(value, problemAnnotation);
 414       }
 415     }
 416
 417     /**
 418      * Tells this annotation model to collect temporary problems from now on.
 419      */
 420     private void startCollectingProblems() {
 421       fCollectedProblems = new ArrayList();
 422       fGeneratedAnnotations = new ArrayList();
 423     }
 424
 425     /**
 426      * Tells this annotation model to no longer collect temporary problems.
 427      */
 428     private void stopCollectingProblems() {
 429       if (fGeneratedAnnotations != null) {
 430         removeAnnotations(fGeneratedAnnotations, true, true);
 431         fGeneratedAnnotations.clear();
 432       }
 433       fCollectedProblems = null;
 434       fGeneratedAnnotations = null;
 435     }
 436
 437     protected void update(IMarkerDelta[] markerDeltas) {
 438
 439       super.update(markerDeltas);
 440
 441       if (markerDeltas != null && markerDeltas.length > 0) {
 442         try {
 443           ICompilationUnit workingCopy = getWorkingCopy(fInput);
 444           if (workingCopy != null)
 445             workingCopy.reconcile(true, null);
 446         } catch (JavaModelException ex) {
 447           handleCoreException(ex, ex.getMessage());
 448         }
 449       }
 450     }
 451   }
 452   /**
 453                  * Creates <code>IBuffer</code>s based on documents.
 454                  */
 455   protected class BufferFactory implements IBufferFactory {
 456
 457     private IDocument internalGetDocument(IFileEditorInput input) throws CoreException {
 458       IDocument document = getDocument(input);
 459       if (document != null)
 460         return document;
 461       return PHPDocumentProvider.this.createDocument(input);
 462     }
 463
 464     public IBuffer createBuffer(IOpenable owner) {
 465       if (owner instanceof ICompilationUnit) {
 466
 467         ICompilationUnit unit = (ICompilationUnit) owner;
 468         ICompilationUnit original = (ICompilationUnit) unit.getOriginalElement();
 469         IResource resource = original.getResource();
 470         if (resource instanceof IFile) {
 471           IFileEditorInput providerKey = new FileEditorInput((IFile) resource);
 472
 473           IDocument document = null;
 474           IStatus status = null;
 475
 476           try {
 477             document = internalGetDocument(providerKey);
 478           } catch (CoreException x) {
 479             status = x.getStatus();
 480             document = new Document();
 481             initializeDocument(document, providerKey);
 482           }
 483
 484           DocumentAdapter adapter =
 485             new DocumentAdapter(unit, document, new DefaultLineTracker(), PHPDocumentProvider.this, providerKey);
 486           adapter.setStatus(status);
 487           return adapter;
 488         }
 489
 490       }
 491       return DocumentAdapter.NULL;
 492     }
 493   };
 494
 495   protected static class GlobalAnnotationModelListener implements IAnnotationModelListener, IAnnotationModelListenerExtension {
 496
 497     private ListenerList fListenerList;
 498
 499     public GlobalAnnotationModelListener() {
 500       fListenerList = new ListenerList();
 501     }
 502
 503     public void addListener(IAnnotationModelListener listener) {
 504       fListenerList.add(listener);
 505     }
 506
 507     /**
 508      * @see IAnnotationModelListenerExtension#modelChanged(AnnotationModelEvent)
 509      */
 510     public void modelChanged(AnnotationModelEvent event) {
 511       Object[] listeners = fListenerList.getListeners();
 512       for (int i = 0; i < listeners.length; i++) {
 513         Object curr = listeners[i];
 514         if (curr instanceof IAnnotationModelListenerExtension) {
 515           ((IAnnotationModelListenerExtension) curr).modelChanged(event);
 516         }
 517       }
 518     }
 519
 520     /**
 521      * @see IAnnotationModelListener#modelChanged(IAnnotationModel)
 522      */
 523     public void modelChanged(IAnnotationModel model) {
 524       Object[] listeners = fListenerList.getListeners();
 525       for (int i = 0; i < listeners.length; i++) {
 526         ((IAnnotationModelListener) listeners[i]).modelChanged(model);
 527       }
 528     }
 529
 530     public void removeListener(IAnnotationModelListener listener) {
 531       fListenerList.remove(listener);
 532     }
 533   }
 534
 535   /**
 536                  * Annotation representating an <code>IProblem</code>.
 537                  */
 538   static protected class ProblemAnnotation extends Annotation implements IJavaAnnotation, IAnnotationExtension{
 539
 540     private static final String TASK_ANNOTATION_TYPE= "org.eclipse.ui.workbench.texteditor.task"; //$NON-NLS-1$
 541     private static final String ERROR_ANNOTATION_TYPE= "org.eclipse.ui.workbench.texteditor.error"; //$NON-NLS-1$
 542     private static final String WARNING_ANNOTATION_TYPE= "org.eclipse.ui.workbench.texteditor.warning"; //$NON-NLS-1$
 543     private static final String INFO_ANNOTATION_TYPE= "org.eclipse.ui.workbench.texteditor.info"; //$NON-NLS-1$
 544
 545     //    private static Image fgQuickFixImage;
 546     //    private static Image fgQuickFixErrorImage;
 547     //    private static boolean fgQuickFixImagesInitialized = false;
 548
 549     private ICompilationUnit fCompilationUnit;
 550     private List fOverlaids;
 551     private IProblem fProblem;
 552     private Image fImage;
 553     //    private boolean fQuickFixImagesInitialized = false;
 554 //    private AnnotationType fType;
 555     private String fType;
 556
 557     public ProblemAnnotation(IProblem problem, ICompilationUnit cu) {
 558       fProblem= problem;
 559       fCompilationUnit= cu;
 560
 561       if (IProblem.Task == fProblem.getID()) {
 562         fType= TASK_ANNOTATION_TYPE;
 563         setLayer(DefaultAnnotation.TASK_LAYER + 1);
 564       } else if (fProblem.isWarning()) {
 565         fType= WARNING_ANNOTATION_TYPE;
 566         setLayer(DefaultAnnotation.WARNING_LAYER + 1);
 567       } else if (fProblem.isError()) {
 568         fType= ERROR_ANNOTATION_TYPE;
 569         setLayer(DefaultAnnotation.ERROR_LAYER + 1);
 570       } else {
 571         fType= INFO_ANNOTATION_TYPE;
 572         setLayer(DefaultAnnotation.INFO_LAYER + 1);
 573       }
 574     }
 575 //    public ProblemAnnotation(IProblem problem) {
 576 //
 577 //      fProblem = problem;
 578 //      setLayer(MarkerAnnotation.PROBLEM_LAYER + 1);
 579 //
 580 //      if (IProblem.Task == fProblem.getID())
 581 //        fType = AnnotationType.TASK;
 582 //      else if (fProblem.isWarning())
 583 //        fType = AnnotationType.WARNING;
 584 //      else
 585 //        fType = AnnotationType.ERROR;
 586 //    }
 587
 588     private void initializeImages() {
 589       // http://bugs.eclipse.org/bugs/show_bug.cgi?id=18936
 590       //      if (!fQuickFixImagesInitialized) {
 591       //        if (indicateQuixFixableProblems() && JavaCorrectionProcessor.hasCorrections(fProblem.getID())) {
 592       //          if (!fgQuickFixImagesInitialized) {
 593       //            fgQuickFixImage = JavaPluginImages.get(JavaPluginImages.IMG_OBJS_FIXABLE_PROBLEM);
 594       //            fgQuickFixErrorImage = JavaPluginImages.get(JavaPluginImages.IMG_OBJS_FIXABLE_ERROR);
 595       //            fgQuickFixImagesInitialized = true;
 596       //          }
 597       //          if (fType == AnnotationType.ERROR)
 598       //            fImage = fgQuickFixErrorImage;
 599       //          else
 600       //            fImage = fgQuickFixImage;
 601       //        }
 602       //        fQuickFixImagesInitialized = true;
 603       //      }
 604     }
 605
 606     private boolean indicateQuixFixableProblems() {
 607       return PreferenceConstants.getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_CORRECTION_INDICATION);
 608     }
 609
 610     /*
 611      * @see Annotation#paint
 612      */
 613     public void paint(GC gc, Canvas canvas, Rectangle r) {
 614       initializeImages();
 615       if (fImage != null)
 616         drawImage(fImage, gc, canvas, r, SWT.CENTER, SWT.TOP);
 617     }
 618
 619     /*
 620      * @see IJavaAnnotation#getImage(Display)
 621      */
 622     public Image getImage(Display display) {
 623       initializeImages();
 624       return fImage;
 625     }
 626
 627     /*
 628      * @see IJavaAnnotation#getMessage()
 629      */
 630     public String getMessage() {
 631       return fProblem.getMessage();
 632     }
 633
 634     /*
 635      * @see IJavaAnnotation#isTemporary()
 636      */
 637     public boolean isTemporary() {
 638       return true;
 639     }
 640
 641     /*
 642      * @see IJavaAnnotation#getArguments()
 643      */
 644     public String[] getArguments() {
 645       return isProblem() ? fProblem.getArguments() : null;
 646     }
 647
 648     /*
 649      * @see IJavaAnnotation#getId()
 650      */
 651     public int getId() {
 652       return isProblem() ? fProblem.getID() : -1;
 653     }
 654
 655 //    /*
 656 //     * @see IJavaAnnotation#isProblem()
 657 //     */
 658 //    public boolean isProblem() {
 659 //      return fType == AnnotationType.WARNING || fType == AnnotationType.ERROR;
 660 //    }
 661     /*
 662      * @see IJavaAnnotation#isProblem()
 663      */
 664     public boolean isProblem() {
 665       return  WARNING_ANNOTATION_TYPE.equals(fType)  || ERROR_ANNOTATION_TYPE.equals(fType);
 666     }
 667
 668     /*
 669      * @see IJavaAnnotation#isRelevant()
 670      */
 671     public boolean isRelevant() {
 672       return true;
 673     }
 674
 675     /*
 676      * @see IJavaAnnotation#hasOverlay()
 677      */
 678     public boolean hasOverlay() {
 679       return false;
 680     }
 681
 682     /*
 683      * @see IJavaAnnotation#addOverlaid(IJavaAnnotation)
 684      */
 685     public void addOverlaid(IJavaAnnotation annotation) {
 686       if (fOverlaids == null)
 687         fOverlaids = new ArrayList(1);
 688       fOverlaids.add(annotation);
 689     }
 690
 691     /*
 692      * @see IJavaAnnotation#removeOverlaid(IJavaAnnotation)
 693      */
 694     public void removeOverlaid(IJavaAnnotation annotation) {
 695       if (fOverlaids != null) {
 696         fOverlaids.remove(annotation);
 697         if (fOverlaids.size() == 0)
 698           fOverlaids = null;
 699       }
 700     }
 701
 702     /*
 703      * @see IJavaAnnotation#getOverlaidIterator()
 704      */
 705     public Iterator getOverlaidIterator() {
 706       if (fOverlaids != null)
 707         return fOverlaids.iterator();
 708       return null;
 709     }
 710
 711
 712     public AnnotationType getAnnotationType() {
 713       if (ERROR_ANNOTATION_TYPE.equals(fType)) {
 714         return AnnotationType.ERROR;
 715       }
 716       if (WARNING_ANNOTATION_TYPE.equals(fType)) {
 717         return AnnotationType.WARNING;
 718       }
 719       if (TASK_ANNOTATION_TYPE.equals(fType)) {
 720         return AnnotationType.TASK;
 721       }
 722 //      if (INFO_ANNOTATION_TYPE.equals(fType)) {
 723 //        return AnnotationType.INFO;
 724 //      }
 725       return AnnotationType.UNKNOWN;
 726     }
 727
 728     /*
 729      * @see IAnnotationExtension#getMarkerType()
 730      */
 731     public String getMarkerType() {
 732       if (isProblem() || INFO_ANNOTATION_TYPE.equals(fType))
 733         return IMarker.PROBLEM;
 734       else
 735         return IMarker.TASK;
 736     }
 737     /*
 738      * @see IAnnotationExtension#getSeverity()
 739      */
 740     public int getSeverity() {
 741       if (ERROR_ANNOTATION_TYPE.equals(fType))
 742         return IMarker.SEVERITY_ERROR;
 743       if (WARNING_ANNOTATION_TYPE.equals(fType))
 744         return IMarker.SEVERITY_WARNING;
 745       return IMarker.SEVERITY_INFO;
 746     }
 747
 748     /*
 749      * @see org.eclipse.jdt.internal.ui.javaeditor.IJavaAnnotation#getCompilationUnit()
 750      */
 751     public ICompilationUnit getCompilationUnit() {
 752       return fCompilationUnit;
 753     }
 754   };
 755   /**
 756                  * Internal structure for mapping positions to some value.
 757                  * The reason for this specific structure is that positions can
 758                  * change over time. Thus a lookup is based on value and not
 759                  * on hash value.
 760                  */
 761   protected static class ReverseMap {
 762
 763     static class Entry {
 764       Position fPosition;
 765       Object fValue;
 766     }
 767     private int fAnchor = 0;
 768
 769     private List fList = new ArrayList(2);
 770
 771     public ReverseMap() {
 772     }
 773
 774     public void clear() {
 775       fList.clear();
 776     }
 777
 778     public Object get(Position position) {
 779
 780       Entry entry;
 781
 782       // behind anchor
 783       int length = fList.size();
 784       for (int i = fAnchor; i < length; i++) {
 785         entry = (Entry) fList.get(i);
 786         if (entry.fPosition.equals(position)) {
 787           fAnchor = i;
 788           return entry.fValue;
 789         }
 790       }
 791
 792       // before anchor
 793       for (int i = 0; i < fAnchor; i++) {
 794         entry = (Entry) fList.get(i);
 795         if (entry.fPosition.equals(position)) {
 796           fAnchor = i;
 797           return entry.fValue;
 798         }
 799       }
 800
 801       return null;
 802     }
 803
 804     private int getIndex(Position position) {
 805       Entry entry;
 806       int length = fList.size();
 807       for (int i = 0; i < length; i++) {
 808         entry = (Entry) fList.get(i);
 809         if (entry.fPosition.equals(position))
 810           return i;
 811       }
 812       return -1;
 813     }
 814
 815     public void put(Position position, Object value) {
 816       int index = getIndex(position);
 817       if (index == -1) {
 818         Entry entry = new Entry();
 819         entry.fPosition = position;
 820         entry.fValue = value;
 821         fList.add(entry);
 822       } else {
 823         Entry entry = (Entry) fList.get(index);
 824         entry.fValue = value;
 825       }
 826     }
 827
 828     public void remove(Position position) {
 829       int index = getIndex(position);
 830       if (index > -1)
 831         fList.remove(index);
 832     }
 833   }
 834
 835   /**
 836                  * Document that can also be used by a background reconciler.
 837                  */
 838   protected static class PartiallySynchronizedDocument extends Document {
 839
 840     /*
 841      * @see IDocumentExtension#startSequentialRewrite(boolean)
 842      */
 843     synchronized public void startSequentialRewrite(boolean normalized) {
 844       super.startSequentialRewrite(normalized);
 845     }
 846
 847     /*
 848      * @see IDocumentExtension#stopSequentialRewrite()
 849      */
 850     synchronized public void stopSequentialRewrite() {
 851       super.stopSequentialRewrite();
 852     }
 853
 854     /*
 855      * @see IDocument#get()
 856      */
 857     synchronized public String get() {
 858       return super.get();
 859     }
 860
 861     /*
 862      * @see IDocument#get(int, int)
 863      */
 864     synchronized public String get(int offset, int length) throws BadLocationException {
 865       return super.get(offset, length);
 866     }
 867
 868     /*
 869      * @see IDocument#getChar(int)
 870      */
 871     synchronized public char getChar(int offset) throws BadLocationException {
 872       return super.getChar(offset);
 873     }
 874
 875     /*
 876      * @see IDocument#replace(int, int, String)
 877      */
 878     synchronized public void replace(int offset, int length, String text) throws BadLocationException {
 879       super.replace(offset, length, text);
 880     }
 881
 882     /*
 883      * @see IDocument#set(String)
 884      */
 885     synchronized public void set(String text) {
 886       super.set(text);
 887     }
 888   };
 889   //
 890   //  private static PHPPartitionScanner HTML_PARTITION_SCANNER = null;
 891   //
 892   //  private static PHPPartitionScanner PHP_PARTITION_SCANNER = null;
 893   //  private static PHPPartitionScanner SMARTY_PARTITION_SCANNER = null;
 894   //
 895   //  // private final static String[] TYPES= new String[] { PHPPartitionScanner.PHP, PHPPartitionScanner.JAVA_DOC, PHPPartitionScanner.JAVA_MULTILINE_COMMENT };
 896   //  private final static String[] TYPES =
 897   //    new String[] {
 898   //      IPHPPartitionScannerConstants.PHP,
 899   //      IPHPPartitionScannerConstants.PHP_MULTILINE_COMMENT,
 900   //      IPHPPartitionScannerConstants.HTML,
 901   //      IPHPPartitionScannerConstants.HTML_MULTILINE_COMMENT,
 902   //      IPHPPartitionScannerConstants.JAVASCRIPT,
 903   //      IPHPPartitionScannerConstants.CSS,
 904   //      IPHPPartitionScannerConstants.SMARTY,
 905   //      IPHPPartitionScannerConstants.SMARTY_MULTILINE_COMMENT };
 906   //  private static PHPPartitionScanner XML_PARTITION_SCANNER = null;
 907
 908   /* Preference key for temporary problems */
 909   private final static String HANDLE_TEMPORARY_PROBLEMS = PreferenceConstants.EDITOR_EVALUTE_TEMPORARY_PROBLEMS;
 910
 911   /** The buffer factory */
 912   private IBufferFactory fBufferFactory = new BufferFactory();
 913   /** Indicates whether the save has been initialized by this provider */
 914   private boolean fIsAboutToSave = false;
 915   /** The save policy used by this provider */
 916   private ISavePolicy fSavePolicy;
 917   /** Internal property changed listener */
 918   private IPropertyChangeListener fPropertyListener;
 919
 920   /** annotation model listener added to all created CU annotation models */
 921   private GlobalAnnotationModelListener fGlobalAnnotationModelListener;
 922
 923   public PHPDocumentProvider() {
 924
 925     fPropertyListener = new IPropertyChangeListener() {
 926       public void propertyChange(PropertyChangeEvent event) {
 927         if (HANDLE_TEMPORARY_PROBLEMS.equals(event.getProperty()))
 928           enableHandlingTemporaryProblems();
 929       }
 930     };
 931
 932     fGlobalAnnotationModelListener = new GlobalAnnotationModelListener();
 933
 934     PHPeclipsePlugin.getDefault().getPreferenceStore().addPropertyChangeListener(fPropertyListener);
 935
 936   }
 937
 938   /**
 939    * Sets the document provider's save policy.
 940    */
 941   public void setSavePolicy(ISavePolicy savePolicy) {
 942     fSavePolicy = savePolicy;
 943   }
 944
 945   /**
 946    * Creates a compilation unit from the given file.
 947    *
 948    * @param file the file from which to create the compilation unit
 949    */
 950   protected ICompilationUnit createCompilationUnit(IFile file) {
 951     Object element = PHPCore.create(file);
 952     if (element instanceof ICompilationUnit)
 953       return (ICompilationUnit) element;
 954     return null;
 955   }
 956
 957   /*
 958          * @see AbstractDocumentProvider#createElementInfo(Object)
 959          */
 960   protected ElementInfo createElementInfo(Object element) throws CoreException {
 961
 962     if (!(element instanceof IFileEditorInput))
 963       return super.createElementInfo(element);
 964
 965     IFileEditorInput input = (IFileEditorInput) element;
 966     ICompilationUnit original = createCompilationUnit(input.getFile());
 967     if (original != null) {
 968
 969       try {
 970
 971         try {
 972           refreshFile(input.getFile());
 973         } catch (CoreException x) {
 974           handleCoreException(x, PHPEditorMessages.getString("PHPDocumentProvider.error.createElementInfo")); //$NON-NLS-1$
 975         }
 976
 977         IAnnotationModel m = createCompilationUnitAnnotationModel(input);
 978         IProblemRequestor r = m instanceof IProblemRequestor ? (IProblemRequestor) m : null;
 979         ICompilationUnit c = (ICompilationUnit) original.getSharedWorkingCopy(getProgressMonitor(), fBufferFactory, r);
 980
 981         DocumentAdapter a = null;
 982         try {
 983           a = (DocumentAdapter) c.getBuffer();
 984         } catch (ClassCastException x) {
 985           IStatus status = new Status(IStatus.ERROR, PHPeclipsePlugin.PLUGIN_ID, PHPStatusConstants.TEMPLATE_IO_EXCEPTION, "Shared working copy has wrong buffer", x); //$NON-NLS-1$
 986           throw new CoreException(status);
 987         }
 988
 989         _FileSynchronizer f = new _FileSynchronizer(input);
 990         f.install();
 991
 992         CompilationUnitInfo info = new CompilationUnitInfo(a.getDocument(), m, f, c);
 993         info.setModificationStamp(computeModificationStamp(input.getFile()));
 994         info.fStatus = a.getStatus();
 995         info.fEncoding = getPersistedEncoding(input);
 996
 997         if (r instanceof IProblemRequestorExtension) {
 998           IProblemRequestorExtension extension = (IProblemRequestorExtension) r;
 999           extension.setIsActive(isHandlingTemporaryProblems());
1000         }
1001         m.addAnnotationModelListener(fGlobalAnnotationModelListener);
1002
1003         return info;
1004
1005       } catch (JavaModelException x) {
1006         throw new CoreException(x.getStatus());
1007       }
1008     } else {
1009       return super.createElementInfo(element);
1010     }
1011   }
1012
1013   /*
1014    * @see AbstractDocumentProvider#disposeElementInfo(Object, ElementInfo)
1015    */
1016   protected void disposeElementInfo(Object element, ElementInfo info) {
1017
1018     if (info instanceof CompilationUnitInfo) {
1019       CompilationUnitInfo cuInfo = (CompilationUnitInfo) info;
1020       cuInfo.fCopy.destroy();
1021       cuInfo.fModel.removeAnnotationModelListener(fGlobalAnnotationModelListener);
1022     }
1023
1024     super.disposeElementInfo(element, info);
1025   }
1026
1027   /*
1028          * @see AbstractDocumentProvider#doSaveDocument(IProgressMonitor, Object, IDocument, boolean)
1029          */
1030   protected void doSaveDocument(IProgressMonitor monitor, Object element, IDocument document, boolean overwrite)
1031     throws CoreException {
1032
1033     ElementInfo elementInfo = getElementInfo(element);
1034     if (elementInfo instanceof CompilationUnitInfo) {
1035       CompilationUnitInfo info = (CompilationUnitInfo) elementInfo;
1036
1037       // update structure, assumes lock on info.fCopy
1038       info.fCopy.reconcile();
1039
1040       ICompilationUnit original = (ICompilationUnit) info.fCopy.getOriginalElement();
1041       IResource resource = original.getResource();
1042
1043       if (resource == null) {
1044         // underlying resource has been deleted, just recreate file, ignore the rest
1045         super.doSaveDocument(monitor, element, document, overwrite);
1046         return;
1047       }
1048
1049       if (resource != null && !overwrite)
1050         checkSynchronizationState(info.fModificationStamp, resource);
1051
1052       if (fSavePolicy != null)
1053         fSavePolicy.preSave(info.fCopy);
1054
1055       // inform about the upcoming content change
1056       fireElementStateChanging(element);
1057       try {
1058         fIsAboutToSave = true;
1059         // commit working copy
1060         info.fCopy.commit(overwrite, monitor);
1061       } catch (CoreException x) {
1062         // inform about the failure
1063         fireElementStateChangeFailed(element);
1064         throw x;
1065       } catch (RuntimeException x) {
1066         // inform about the failure
1067         fireElementStateChangeFailed(element);
1068         throw x;
1069       } finally {
1070         fIsAboutToSave = false;
1071       }
1072
1073       // If here, the dirty state of the editor will change to "not dirty".
1074       // Thus, the state changing flag will be reset.
1075
1076       AbstractMarkerAnnotationModel model = (AbstractMarkerAnnotationModel) info.fModel;
1077       model.updateMarkers(info.fDocument);
1078
1079       if (resource != null)
1080         info.setModificationStamp(computeModificationStamp(resource));
1081
1082       if (fSavePolicy != null) {
1083         ICompilationUnit unit = fSavePolicy.postSave(original);
1084         if (unit != null) {
1085           IResource r = unit.getResource();
1086           IMarker[] markers = r.findMarkers(IMarker.MARKER, true, IResource.DEPTH_ZERO);
1087           if (markers != null && markers.length > 0) {
1088             for (int i = 0; i < markers.length; i++)
1089               model.updateMarker(markers[i], info.fDocument, null);
1090           }
1091         }
1092       }
1093
1094     } else {
1095       super.doSaveDocument(monitor, element, document, overwrite);
1096     }
1097   }
1098
1099   /**
1100    * Replaces createAnnotionModel of the super class.
1101    */
1102   protected IAnnotationModel createCompilationUnitAnnotationModel(Object element) throws CoreException {
1103                 if ( !(element instanceof IFileEditorInput))
1104                         throw new CoreException(PHPUIStatus.createError(
1105                                 IJavaModelStatusConstants.INVALID_RESOURCE_TYPE, "", null)); //$NON-NLS-1$
1106
1107                 IFileEditorInput input= (IFileEditorInput) element;
1108                 return new CompilationUnitAnnotationModel(input);
1109   }
1110
1111   //  private IDocumentPartitioner createCSSPartitioner() {
1112   //    return new DefaultPartitioner(getHTMLPartitionScanner(), TYPES);
1113   //  }
1114
1115   /* (non-Javadoc)
1116    * Method declared on AbstractDocumentProvider
1117    */
1118   protected IDocument createDocument(Object element) throws CoreException {
1119     if (element instanceof IEditorInput) {
1120       Document document = new PartiallySynchronizedDocument();
1121       if (setDocumentContent(document, (IEditorInput) element, getEncoding(element))) {
1122         initializeDocument(document, (IEditorInput) element);
1123
1124         //
1125         //    IDocument document = super.createDocument(element);
1126         //    if (document != null) {
1127         //        IDocumentPartitioner partitioner = null;
1128         //        if (element instanceof FileEditorInput) {
1129         //          IFile file = (IFile) ((FileEditorInput) element).getAdapter(IFile.class);
1130         //          String filename = file.getLocation().toString();
1131         //          String extension = filename.substring(filename.lastIndexOf("."), filename.length());
1132         //          //   System.out.println(extension);
1133         //          if (extension.equalsIgnoreCase(".html") || extension.equalsIgnoreCase(".htm")) {
1134         //            // html
1135         //            partitioner = createHTMLPartitioner();
1136         //          } else if (extension.equalsIgnoreCase(".xml")) {
1137         //            // xml
1138         //            partitioner = createXMLPartitioner();
1139         //          } else if (extension.equalsIgnoreCase(".js")) {
1140         //            // javascript
1141         //            partitioner = createJavaScriptPartitioner();
1142         //          } else if (extension.equalsIgnoreCase(".css")) {
1143         //            // cascading style sheets
1144         //            partitioner = createCSSPartitioner();
1145         //          } else if (extension.equalsIgnoreCase(".tpl")) {
1146         //            // smarty ?
1147         //            partitioner = createSmartyPartitioner();
1148         //          } else if (extension.equalsIgnoreCase(".inc")) {
1149         //            // php include files ?
1150         //            partitioner = createIncludePartitioner();
1151         //          }
1152         //        }
1153         //
1154         //        if (partitioner == null) {
1155         //          partitioner = createPHPPartitioner();
1156         //        }
1157         //        document.setDocumentPartitioner(partitioner);
1158         //        partitioner.connect(document);
1159       }
1160       return document;
1161     }
1162     return null;
1163   }
1164
1165   //  /**
1166   //   * Return a partitioner for .html files.
1167   //   */
1168   //  private IDocumentPartitioner createHTMLPartitioner() {
1169   //    return new DefaultPartitioner(getHTMLPartitionScanner(), TYPES);
1170   //  }
1171   //
1172   //  private IDocumentPartitioner createIncludePartitioner() {
1173   //    return new DefaultPartitioner(getPHPPartitionScanner(), TYPES);
1174   //  }
1175   //
1176   //  private IDocumentPartitioner createJavaScriptPartitioner() {
1177   //    return new DefaultPartitioner(getHTMLPartitionScanner(), TYPES);
1178   //  }
1179
1180   /**
1181    * Creates a line tracker working with the same line delimiters as the document
1182    * of the given element. Assumes the element to be managed by this document provider.
1183    *
1184    * @param element the element serving as blue print
1185    * @return a line tracker based on the same line delimiters as the element's document
1186    */
1187   public ILineTracker createLineTracker(Object element) {
1188     return new DefaultLineTracker();
1189   }
1190
1191   //  /**
1192   //   * Return a partitioner for .php files.
1193   //   */
1194   //  private IDocumentPartitioner createPHPPartitioner() {
1195   //    return new DefaultPartitioner(getPHPPartitionScanner(), TYPES);
1196   //  }
1197   //
1198   //  private IDocumentPartitioner createSmartyPartitioner() {
1199   //    return new DefaultPartitioner(getSmartyPartitionScanner(), TYPES);
1200   //  }
1201   //
1202   //  private IDocumentPartitioner createXMLPartitioner() {
1203   //    return new DefaultPartitioner(getXMLPartitionScanner(), TYPES);
1204   //  }
1205   //
1206   //  /**
1207   //   * Return a scanner for creating html partitions.
1208   //   */
1209   //  private PHPPartitionScanner getHTMLPartitionScanner() {
1210   //    if (HTML_PARTITION_SCANNER == null)
1211   //      HTML_PARTITION_SCANNER = new PHPPartitionScanner(IPHPPartitionScannerConstants.HTML_FILE);
1212   //    return HTML_PARTITION_SCANNER;
1213   //  }
1214   //  /**
1215   //   * Return a scanner for creating php partitions.
1216   //   */
1217   //  private PHPPartitionScanner getPHPPartitionScanner() {
1218   //    if (PHP_PARTITION_SCANNER == null)
1219   //      PHP_PARTITION_SCANNER = new PHPPartitionScanner(IPHPPartitionScannerConstants.PHP_FILE);
1220   //    return PHP_PARTITION_SCANNER;
1221   //  }
1222   //
1223   //  /**
1224   //   * Return a scanner for creating smarty partitions.
1225   //   */
1226   //  private PHPPartitionScanner getSmartyPartitionScanner() {
1227   //    if (SMARTY_PARTITION_SCANNER == null)
1228   //      SMARTY_PARTITION_SCANNER = new PHPPartitionScanner(IPHPPartitionScannerConstants.SMARTY_FILE);
1229   //    return SMARTY_PARTITION_SCANNER;
1230   //  }
1231   //
1232   //  /**
1233   //   * Return a scanner for creating xml partitions.
1234   //   */
1235   //  private PHPPartitionScanner getXMLPartitionScanner() {
1236   //    if (XML_PARTITION_SCANNER == null)
1237   //      XML_PARTITION_SCANNER = new PHPPartitionScanner(IPHPPartitionScannerConstants.XML_FILE);
1238   //    return XML_PARTITION_SCANNER;
1239   //  }
1240
1241   protected void initializeDocument(IDocument document, IEditorInput editorInput) {
1242     if (document != null) {
1243       JavaTextTools tools = PHPeclipsePlugin.getDefault().getJavaTextTools();
1244       IDocumentPartitioner partitioner = null;
1245       if (editorInput != null && editorInput instanceof FileEditorInput) {
1246         IFile file = (IFile) ((FileEditorInput) editorInput).getAdapter(IFile.class);
1247         String filename = file.getLocation().toString();
1248         String extension = filename.substring(filename.lastIndexOf("."), filename.length());
1249         partitioner = tools.createDocumentPartitioner(extension);
1250       } else {
1251         partitioner = tools.createDocumentPartitioner(".php");
1252       }
1253       document.setDocumentPartitioner(partitioner);
1254       partitioner.connect(document);
1255     }
1256   }
1257
1258   /*
1259    * @see org.eclipse.ui.texteditor.AbstractDocumentProvider#doResetDocument(java.lang.Object, org.eclipse.core.runtime.IProgressMonitor)
1260    */
1261   protected void doResetDocument(Object element, IProgressMonitor monitor) throws CoreException {
1262     if (element == null)
1263       return;
1264
1265     ElementInfo elementInfo= getElementInfo(element);
1266     if (elementInfo instanceof CompilationUnitInfo) {
1267       CompilationUnitInfo info= (CompilationUnitInfo) elementInfo;
1268
1269       IDocument document;
1270       IStatus status= null;
1271
1272       try {
1273
1274         ICompilationUnit original= (ICompilationUnit) info.fCopy.getOriginalElement();
1275         IResource resource= original.getResource();
1276         if (resource instanceof IFile) {
1277
1278           IFile file= (IFile) resource;
1279
1280           try {
1281             refreshFile(file, monitor);
1282           } catch (CoreException x) {
1283             handleCoreException(x, PHPEditorMessages.getString("CompilationUnitDocumentProvider.error.resetDocument")); //$NON-NLS-1$
1284           }
1285
1286           IFileEditorInput input= new FileEditorInput(file);
1287           document= super.createDocument(input);
1288
1289         } else {
1290           document= createEmptyDocument();
1291         }
1292
1293       } catch (CoreException x) {
1294         document= createEmptyDocument();
1295         status= x.getStatus();
1296       }
1297
1298       fireElementContentAboutToBeReplaced(element);
1299
1300       removeUnchangedElementListeners(element, info);
1301       info.fDocument.set(document.get());
1302       info.fCanBeSaved= false;
1303       info.fStatus= status;
1304       addUnchangedElementListeners(element, info);
1305
1306       fireElementContentReplaced(element);
1307       fireElementDirtyStateChanged(element, false);
1308
1309     } else {
1310       super.doResetDocument(element, monitor);
1311     }
1312   }
1313
1314   /*
1315    * @see AbstractDocumentProvider#resetDocument(Object)
1316    */
1317 //  public void resetDocument(Object element) throws CoreException {
1318 //    if (element == null)
1319 //      return;
1320 //
1321 //    ElementInfo elementInfo = getElementInfo(element);
1322 //    if (elementInfo instanceof CompilationUnitInfo) {
1323 //      CompilationUnitInfo info = (CompilationUnitInfo) elementInfo;
1324 //
1325 //      IDocument document;
1326 //      IStatus status = null;
1327 //
1328 //      try {
1329 //
1330 //        ICompilationUnit original = (ICompilationUnit) info.fCopy.getOriginalElement();
1331 //        IResource resource = original.getResource();
1332 //        if (resource instanceof IFile) {
1333 //
1334 //          IFile file = (IFile) resource;
1335 //
1336 //          try {
1337 //            refreshFile(file);
1338 //          } catch (CoreException x) {
1339 //            handleCoreException(x, PHPEditorMessages.getString("PHPDocumentProvider.error.resetDocument")); //$NON-NLS-1$
1340 //          }
1341 //
1342 //          IFileEditorInput input = new FileEditorInput(file);
1343 //          document = super.createDocument(input);
1344 //
1345 //        } else {
1346 //          document = new Document();
1347 //        }
1348 //
1349 //      } catch (CoreException x) {
1350 //        document = new Document();
1351 //        status = x.getStatus();
1352 //      }
1353 //
1354 //      fireElementContentAboutToBeReplaced(element);
1355 //
1356 //      removeUnchangedElementListeners(element, info);
1357 //      info.fDocument.set(document.get());
1358 //      info.fCanBeSaved = false;
1359 //      info.fStatus = status;
1360 //      addUnchangedElementListeners(element, info);
1361 //
1362 //      fireElementContentReplaced(element);
1363 //      fireElementDirtyStateChanged(element, false);
1364 //
1365 //    } else {
1366 //      super.resetDocument(element);
1367 //    }
1368 //  }
1369   /**
1370          * Saves the content of the given document to the given element.
1371          * This is only performed when this provider initiated the save.
1372          *
1373          * @param monitor the progress monitor
1374          * @param element the element to which to save
1375          * @param document the document to save
1376          * @param overwrite <code>true</code> if the save should be enforced
1377          */
1378   public void saveDocumentContent(IProgressMonitor monitor, Object element, IDocument document, boolean overwrite)
1379     throws CoreException {
1380
1381     if (!fIsAboutToSave)
1382       return;
1383
1384     if (element instanceof IFileEditorInput) {
1385       IFileEditorInput input = (IFileEditorInput) element;
1386       try {
1387         String encoding = getEncoding(element);
1388         if (encoding == null)
1389           encoding = ResourcesPlugin.getEncoding();
1390         InputStream stream = new ByteArrayInputStream(document.get().getBytes(encoding));
1391         IFile file = input.getFile();
1392         file.setContents(stream, overwrite, true, monitor);
1393       } catch (IOException x) {
1394         IStatus s = new Status(IStatus.ERROR, PHPeclipsePlugin.PLUGIN_ID, IStatus.OK, x.getMessage(), x);
1395         throw new CoreException(s);
1396       }
1397     }
1398   }
1399   /**
1400    * Returns the underlying resource for the given element.
1401    *
1402    * @param the element
1403    * @return the underlying resource of the given element
1404    */
1405   public IResource getUnderlyingResource(Object element) {
1406     if (element instanceof IFileEditorInput) {
1407       IFileEditorInput input = (IFileEditorInput) element;
1408       return input.getFile();
1409     }
1410     return null;
1411   }
1412
1413   /**
1414    * Returns the working copy this document provider maintains for the given
1415    * element.
1416    *
1417    * @param element the given element
1418    * @return the working copy for the given element
1419    */
1420   ICompilationUnit getWorkingCopy(IEditorInput element) {
1421
1422     ElementInfo elementInfo = getElementInfo(element);
1423     if (elementInfo instanceof CompilationUnitInfo) {
1424       CompilationUnitInfo info = (CompilationUnitInfo) elementInfo;
1425       return info.fCopy;
1426     }
1427
1428     return null;
1429   }
1430
1431   /**
1432    * Gets the BufferFactory.
1433    */
1434   public IBufferFactory getBufferFactory() {
1435     return fBufferFactory;
1436   }
1437
1438   /**
1439    * Shuts down this document provider.
1440    */
1441   public void shutdown() {
1442
1443     PHPeclipsePlugin.getDefault().getPreferenceStore().removePropertyChangeListener(fPropertyListener);
1444
1445     Iterator e = getConnectedElements();
1446     while (e.hasNext())
1447       disconnect(e.next());
1448   }
1449
1450   /**
1451    * Returns the preference whether handling temporary problems is enabled.
1452    */
1453   protected boolean isHandlingTemporaryProblems() {
1454     IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
1455     return store.getBoolean(HANDLE_TEMPORARY_PROBLEMS);
1456   }
1457
1458   /**
1459    * Switches the state of problem acceptance according to the value in the preference store.
1460    */
1461   protected void enableHandlingTemporaryProblems() {
1462     boolean enable = isHandlingTemporaryProblems();
1463     for (Iterator iter = getConnectedElements(); iter.hasNext();) {
1464       ElementInfo element = getElementInfo(iter.next());
1465       if (element instanceof CompilationUnitInfo) {
1466         CompilationUnitInfo info = (CompilationUnitInfo) element;
1467         if (info.fModel instanceof IProblemRequestorExtension) {
1468           IProblemRequestorExtension extension = (IProblemRequestorExtension) info.fModel;
1469           extension.setIsActive(enable);
1470         }
1471       }
1472     }
1473   }
1474
1475   /**
1476    * Adds a listener that reports changes from all compilation unit annotation models.
1477    */
1478   public void addGlobalAnnotationModelListener(IAnnotationModelListener listener) {
1479     fGlobalAnnotationModelListener.addListener(listener);
1480   }
1481
1482   /**
1483    * Removes the listener.
1484    */
1485   public void removeGlobalAnnotationModelListener(IAnnotationModelListener listener) {
1486     fGlobalAnnotationModelListener.removeListener(listener);
1487   }
1488
1489   /**
1490    * Returns whether the given element is connected to this document provider.
1491    *
1492    * @param element the element
1493    * @return <code>true</code> if the element is connected, <code>false</code> otherwise
1494    */
1495   boolean isConnected(Object element) {
1496     return getElementInfo(element) != null;
1497   }
1498 }