private synchronized void checkFile() {
    if (fActiveEditor == null) return;
    IEditorInput input = fActiveEditor.getEditorInput();
    IPath location = null;

    if (input instanceof IFileEditorInput) {
      IFile file = ((IFileEditorInput) input).getFile();
      location = file.getLocation();
    } else if (input instanceof FileStoreEditorInput) {
      location = URIUtil.toPath(((FileStoreEditorInput) input).getURI());
    } else if (input instanceof CommonSourceNotFoundEditorInput) {
      Object artifact = ((CommonSourceNotFoundEditorInput) input).getArtifact();
      if (artifact instanceof CSourceNotFoundElement) {
        location = new Path(((CSourceNotFoundElement) artifact).getFile());
      }
    }

    if (location != null
        && fExpectedFile != null
        && location.lastSegment().equals(fExpectedFile.lastSegment())) {
      fFileFound = true;

      if (fActiveEditor instanceof ITextEditor) {
        IDocumentProvider docProvider = ((ITextEditor) fActiveEditor).getDocumentProvider();
        fAnnotationModel = docProvider.getAnnotationModel(fActiveEditor.getEditorInput());
        fAnnotationModel.addAnnotationModelListener(this);

        checkAnnotations();
      } else if (fActiveEditor instanceof CommonSourceNotFoundEditor) {
        // No annotation will be painted if source not found.
        fAnnotationFound = true;
      }
    }
  }
  void removeOccurrenceAnnotations() {
    fMarkOccurrenceModificationStamp = IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP;
    fMarkOccurrenceTargetRegion = null;

    final IDocumentProvider documentProvider = erlangEditor.getDocumentProvider();
    if (documentProvider == null) {
      return;
    }

    final IAnnotationModel annotationModel =
        documentProvider.getAnnotationModel(erlangEditor.getEditorInput());
    if (annotationModel == null || fOccurrenceAnnotations == null) {
      return;
    }

    synchronized (erlangEditor.getLockObject(annotationModel)) {
      if (annotationModel instanceof IAnnotationModelExtension) {
        ((IAnnotationModelExtension) annotationModel)
            .replaceAnnotations(fOccurrenceAnnotations, null);
      } else {
        for (int i = 0, length = fOccurrenceAnnotations.length; i < length; i++) {
          annotationModel.removeAnnotation(fOccurrenceAnnotations[i]);
        }
      }
      fOccurrenceAnnotations = null;
    }
  }
  /**
   * Attaches a coverage annotation model for the given editor if the editor can be annotated. Does
   * nothing if the model is already attached.
   *
   * @param editor Editor to attach a annotation model to
   */
  public static boolean attach(ITextEditor editor) {
    IDocumentProvider provider = editor.getDocumentProvider();
    IEditorInput input = editor.getEditorInput();

    if (provider != null && input instanceof FileEditorInput) {
      IAnnotationModel model = provider.getAnnotationModel(input);

      if (model instanceof IAnnotationModelExtension) {
        IAnnotationModelExtension modelex = (IAnnotationModelExtension) model;

        ColorAnnotationModel colormodel = (ColorAnnotationModel) modelex.getAnnotationModel(KEY);

        if (colormodel == null) {
          IFile file = ((FileEditorInput) input).getFile();
          IFeatureProject project = CorePlugin.getFeatureProject(file);
          if (project != null
              && project.getComposer() != null
              && project.getComposer().needColor()) {
            IDocument document = provider.getDocument(input);
            colormodel = new ColorAnnotationModel(document, file, project, editor);
            modelex.addAnnotationModel(KEY, colormodel);

            return true;
          }
        } else {
          colormodel.updateAnnotations(!editor.isDirty());
        }
      }
    }
    return false;
  }
 /**
  * Returns the <code>AbstractMarkerAnnotationModel</code> of the editor's input.
  *
  * @return the marker annotation model
  */
 protected AbstractMarkerAnnotationModel getAnnotationModel() {
   IDocumentProvider provider = fTextEditor.getDocumentProvider();
   IAnnotationModel model = provider.getAnnotationModel(fTextEditor.getEditorInput());
   if (model instanceof AbstractMarkerAnnotationModel) {
     return (AbstractMarkerAnnotationModel) model;
   }
   return null;
 }
 /**
  * Detaches the coverage annotation model from the given editor. If the editor does not have a
  * model attached, this method does nothing.
  *
  * @param editor Editor to detach the annotation model from
  */
 public static void detach(ITextEditor editor) {
   IDocumentProvider provider = editor.getDocumentProvider();
   // there may be text editors without document providers (SF #1725100)
   if (provider == null) return;
   IAnnotationModel model = provider.getAnnotationModel(editor.getEditorInput());
   if (!(model instanceof IAnnotationModelExtension)) return;
   IAnnotationModelExtension modelex = (IAnnotationModelExtension) model;
   modelex.removeAnnotationModel(KEY);
 }
 private IAnnotationModel getAnnotationModel() {
   if (fTextEditor == null) {
     return null;
   }
   final IDocumentProvider documentProvider = fTextEditor.getDocumentProvider();
   if (documentProvider == null) {
     return null;
   }
   return documentProvider.getAnnotationModel(fTextEditor.getEditorInput());
 }
  /**
   * Detaches the coverage annotation model from the given editor. If the editor does not have a
   * model attached, this method does nothing.
   *
   * @param editor Editor to detach the annotation model from
   */
  public static void detach(ITextEditor editor) {
    IDocumentProvider provider = editor.getDocumentProvider();
    if (provider != null) {
      IAnnotationModel model = provider.getAnnotationModel(editor.getEditorInput());

      if (model instanceof IAnnotationModelExtension) {
        IAnnotationModelExtension modelex = (IAnnotationModelExtension) model;

        modelex.removeAnnotationModel(KEY);
      }
    }
  }
 protected IAnnotationModel getAnnotationModel(XtextEditor editor) {
   if (editor != null) {
     IEditorInput editorInput = editor.getEditorInput();
     if (editorInput != null) {
       IDocumentProvider documentProvider = editor.getDocumentProvider();
       if (documentProvider != null) {
         return documentProvider.getAnnotationModel(editorInput);
       }
     }
   }
   return null;
 }
  /**
   * Attaches a coverage annotation model for the given editor if the editor can be annotated. Does
   * nothing if the model is already attached.
   *
   * @param editor Editor to attach a annotation model to
   */
  public static void attach(ITextEditor editor) {
    IDocumentProvider provider = editor.getDocumentProvider();
    // there may be text editors without document providers (SF #1725100)
    if (provider == null) return;
    IAnnotationModel model = provider.getAnnotationModel(editor.getEditorInput());
    if (!(model instanceof IAnnotationModelExtension)) return;
    IAnnotationModelExtension modelex = (IAnnotationModelExtension) model;

    IDocument document = provider.getDocument(editor.getEditorInput());

    CoverageAnnotationModel coveragemodel =
        (CoverageAnnotationModel) modelex.getAnnotationModel(KEY);
    if (coveragemodel == null) {
      coveragemodel = new CoverageAnnotationModel(editor, document);
      modelex.addAnnotationModel(KEY, coveragemodel);
    }
  }
  public void removeAnnotations() {
    final IDocumentProvider docProvider = fEditor.getDocumentProvider();

    if (docProvider == null) {
      return;
    }

    IAnnotationModel model = docProvider.getAnnotationModel(fEditor.getEditorInput());

    if (model == null) return;

    for (Iterator i = model.getAnnotationIterator(); i.hasNext(); ) {
      Annotation a = (Annotation) i.next();

      if (a.getType().equals(fAnnotationType)) model.removeAnnotation(a);
    }
  }
  private void initializeSourceViewer(IEditorInput input) {

    IDocumentProvider documentProvider = getDocumentProvider();
    IAnnotationModel model = documentProvider.getAnnotationModel(input);
    IDocument document = documentProvider.getDocument(input);

    if (document != null) {
      fSourceViewer.setDocument(document, model);
      fSourceViewer.setEditable(isEditable());
      fSourceViewer.showAnnotations(model != null);
    }

    if (fElementStateListener instanceof IElementStateListenerExtension) {
      boolean isStateValidated = false;
      if (documentProvider instanceof IDocumentProviderExtension)
        isStateValidated = ((IDocumentProviderExtension) documentProvider).isStateValidated(input);

      IElementStateListenerExtension extension =
          (IElementStateListenerExtension) fElementStateListener;
      extension.elementStateValidationChanged(input, isStateValidated);
    }
  }
  @Nullable
  private DiagnosticAnnotation getAnnotationByOffset(int offset) {
    AbstractTextEditor editor = getActiveEditor();
    if (editor == null) {
      return null;
    }

    IDocumentProvider documentProvider = editor.getDocumentProvider();
    IAnnotationModel annotationModel = documentProvider.getAnnotationModel(editor.getEditorInput());

    for (Iterator<?> i = annotationModel.getAnnotationIterator(); i.hasNext(); ) {
      Annotation annotation = (Annotation) i.next();
      if (annotation instanceof DiagnosticAnnotation) {
        DiagnosticAnnotation diagnosticAnnotation = (DiagnosticAnnotation) annotation;

        TextRange range = diagnosticAnnotation.getRange();
        if (range.getStartOffset() <= offset && range.getEndOffset() >= offset) {
          return diagnosticAnnotation;
        }
      }
    }

    return null;
  }
    private void findAnnotation() {
      mPosition = null;
      mCanFix = false;

      IDocumentProvider provider = mTextEditor.getDocumentProvider();
      IAnnotationModel model = provider.getAnnotationModel(mTextEditor.getEditorInput());
      IAnnotationAccessExtension annotationAccess = getAnnotationAccessExtension();

      IDocument document = getDocument();
      if (model == null) {
        return;
      }

      Iterator<?> iter = model.getAnnotationIterator();
      int layer = Integer.MIN_VALUE;

      while (iter.hasNext()) {
        Annotation annotation = (Annotation) iter.next();
        if (annotation.isMarkedDeleted()) {
          continue;
        }

        int annotationLayer = Integer.MAX_VALUE;
        if (annotationAccess != null) {
          annotationLayer = annotationAccess.getLayer(annotation);
          if (annotationLayer < layer) {
            continue;
          }
        }

        Position position = model.getPosition(annotation);
        if (!includesRulerLine(position, document)) {
          continue;
        }

        boolean isReadOnly =
            mTextEditor instanceof ITextEditorExtension
                && ((ITextEditorExtension) mTextEditor).isEditorInputReadOnly();
        if (!isReadOnly
            && annotation instanceof INIProblemAnnotation
            && ((INIProblemAnnotation) annotation).isQuickFixable()) {
          mPosition = position;
          mCanFix = true;
          layer = annotationLayer;
          continue;
        } else {
          AnnotationPreference preference =
              mAnnotationPreferenceLookup.getAnnotationPreference(annotation);
          if (preference == null) {
            continue;
          }

          String key = preference.getVerticalRulerPreferenceKey();
          if (key == null) {
            continue;
          }

          if (mStore.getBoolean(key)) {
            mPosition = position;
            mCanFix = false;
            layer = annotationLayer;
          }
        }
      }
    }
    /*
     * @see Job#run(org.eclipse.core.runtime.IProgressMonitor)
     */
    public IStatus run(IProgressMonitor progressMonitor) {
      if (isCanceled(progressMonitor)) {
        return Status.CANCEL_STATUS;
      }

      ITextViewer textViewer = editor.getISourceViewer();
      if (textViewer == null) {
        return Status.CANCEL_STATUS;
      }

      IDocument document = textViewer.getDocument();
      if (document == null) {
        return Status.CANCEL_STATUS;
      }

      IDocumentProvider documentProvider = editor.getDocumentProvider();
      if (documentProvider == null) {
        return Status.CANCEL_STATUS;
      }

      IAnnotationModel annotationModel =
          documentProvider.getAnnotationModel(editor.getEditorInput());
      if (annotationModel == null) {
        return Status.CANCEL_STATUS;
      }

      int length = fLocations.length;
      Map<Annotation, Position> annotationMap = new HashMap<Annotation, Position>(length);
      for (int i = 0; i < length; i++) {

        if (isCanceled(progressMonitor)) {
          return Status.CANCEL_STATUS;
        }

        OccurrenceLocation occurrence = fLocations[i];
        Position position = new Position(occurrence.getOffset(), occurrence.getLength());

        String description = occurrence.getDescription();
        String annotationType =
            (occurrence.getFlags() == IOccurrencesFinder.F_WRITE_OCCURRENCE)
                ? WRITE_OCCURRENCE_ID
                : READ_OCCURRENCE_ID;

        /*
         * // create an annotation to mark the occurrence ReconcileAnnotationKey reconcileAnnotationKey = new
         * ReconcileAnnotationKey(null, PHPPartitionTypes.PHP_DEFAULT, ReconcileAnnotationKey.TOTAL);
         * TemporaryAnnotation annotation = new TemporaryAnnotation(position, annotationType, description,
         * reconcileAnnotationKey) {
         */
        /**
         * Paint the ruler annotation.
         *
         * @param gc
         * @param canvas
         * @param r
         */
        /*
         * @Override public void paint(GC gc, Canvas canvas, Rectangle r) { // TODO - Shalom: Change this image
         * location ImageUtilities.drawImage(PHPUiPlugin.getImageDescriptorRegistry().get(
         * PHPPluginImages.DESC_OBJS_OCCURRENCES), gc, canvas, r, SWT.CENTER, SWT.TOP); } };
         */
        Annotation annotation = new Annotation(annotationType, false, description);
        annotationMap.put(annotation, position);
      }

      if (isCanceled(progressMonitor)) return Status.CANCEL_STATUS;

      synchronized (getAnnotationModelLock(annotationModel)) {
        if (annotationModel instanceof IAnnotationModelExtension) {
          ((IAnnotationModelExtension) annotationModel)
              .replaceAnnotations(fOccurrenceAnnotations, annotationMap);
        } else {
          removeOccurrenceAnnotations();
          for (Map.Entry<Annotation, Position> entry : annotationMap.entrySet()) {
            annotationModel.addAnnotation(entry.getKey(), entry.getValue());
          }
        }
        fOccurrenceAnnotations =
            annotationMap.keySet().toArray(new Annotation[annotationMap.keySet().size()]);
      }

      return Status.OK_STATUS;
    }
    /*
     * @see Job#run(org.eclipse.core.runtime.IProgressMonitor)
     */
    @Override
    public IStatus run(final IProgressMonitor progressMonitor) {
      findRefs(module, selection, fHasChanged);
      if (fRefs == null) {
        return Status.CANCEL_STATUS;
      }

      if (isCanceled(progressMonitor)) {
        return Status.CANCEL_STATUS;
      }

      final ITextViewer textViewer = erlangEditor.getViewer();
      if (textViewer == null) {
        return Status.CANCEL_STATUS;
      }

      final IDocument document = textViewer.getDocument();
      if (document == null) {
        return Status.CANCEL_STATUS;
      }

      final IDocumentProvider documentProvider = erlangEditor.getDocumentProvider();
      if (documentProvider == null) {
        return Status.CANCEL_STATUS;
      }

      final IAnnotationModel annotationModel =
          documentProvider.getAnnotationModel(erlangEditor.getEditorInput());
      if (annotationModel == null) {
        return Status.CANCEL_STATUS;
      }

      // Add occurrence annotations
      final HashMap<Annotation, Position> annotationMap =
          new HashMap<Annotation, Position>(fRefs.size());
      for (final MarkOccurencesHandler.ErlangRef ref : fRefs) {
        if (isCanceled(progressMonitor)) {
          return Status.CANCEL_STATUS;
        }

        final Position position = new Position(ref.getOffset(), ref.getLength());

        final String description = ref.getDescription();
        final String annotationType =
            ref.isDef()
                ? "org.erlide.ui.occurrences.definition" //$NON-NLS-1$
                : "org.erlide.ui.occurrences";

        annotationMap.put(new Annotation(annotationType, false, description), position);
      }

      if (isCanceled(progressMonitor)) {
        return Status.CANCEL_STATUS;
      }

      synchronized (erlangEditor.getLockObject(annotationModel)) {
        if (annotationModel instanceof IAnnotationModelExtension) {
          ((IAnnotationModelExtension) annotationModel)
              .replaceAnnotations(
                  erlangEditor.markOccurencesHandler.fOccurrenceAnnotations, annotationMap);
        } else {
          erlangEditor.markOccurencesHandler.removeOccurrenceAnnotations();
          for (final Map.Entry<Annotation, Position> mapEntry : annotationMap.entrySet()) {
            annotationModel.addAnnotation(mapEntry.getKey(), mapEntry.getValue());
          }
        }
        erlangEditor.markOccurencesHandler.fOccurrenceAnnotations =
            annotationMap.keySet().toArray(new Annotation[annotationMap.keySet().size()]);
      }

      return Status.OK_STATUS;
    }
 private IProblemRequestorExtension getProblemRequestorExtension() {
   IAnnotationModel model = fDocumentProvider.getAnnotationModel(fEditor.getEditorInput());
   if (model instanceof IProblemRequestorExtension) return (IProblemRequestorExtension) model;
   return null;
 }
Exemple #17
0
 private void updateAnnotations(IWorkbenchWindow window, TCFNode node, Set<TCFAnnotation> set) {
   if (disposed) return;
   assert Thread.currentThread() == display.getThread();
   WorkbenchWindowInfo win_info = windows.get(window);
   if (win_info == null) return;
   Map<IEditorInput, IEditorPart> editors = new HashMap<IEditorInput, IEditorPart>();
   Map<IViewPart, ITCFDisassemblyPart> views = new HashMap<IViewPart, ITCFDisassemblyPart>();
   IWorkbenchPage page = window.getActivePage();
   if (page != null) {
     for (IEditorReference ref : page.getEditorReferences()) {
       IEditorPart editor = ref.getEditor(false);
       if (editor == null) continue;
       editors.put(editor.getEditorInput(), editor);
     }
     for (IViewReference ref : page.getViewReferences()) {
       IViewPart view = ref.getView(false);
       if (view == null) continue;
       ITCFDisassemblyPart disasm =
           (ITCFDisassemblyPart) view.getAdapter(ITCFDisassemblyPart.class);
       if (disasm != null) views.put(view, disasm);
     }
   }
   boolean flush_all =
       node == null
           || !views.keySet().equals(win_info.views.keySet())
           || !editors.equals(win_info.editors)
           || changed_launch_cfgs.contains(node.launch);
   win_info.views.clear();
   win_info.views.putAll(views);
   win_info.editors.clear();
   win_info.editors.putAll(editors);
   Iterator<TCFAnnotation> i = win_info.annotations.iterator();
   while (i.hasNext()) {
     TCFAnnotation a = i.next();
     if (!flush_all && set != null && set.remove(a)) continue;
     a.dispose();
     i.remove();
   }
   if (set != null) win_info.annotations.addAll(set);
   ISourcePresentation presentation = TCFModelPresentation.getDefault();
   // Disassembly views
   for (TCFAnnotation a : win_info.annotations) {
     if (a.addr == null) continue;
     for (ITCFDisassemblyPart disasm : views.values()) {
       IAnnotationModel ann_model = disasm.getAnnotationModel();
       if (ann_model == null) continue;
       if (a.models.contains(ann_model)) {
         ann_model.removeAnnotation(a);
         a.models.remove(ann_model);
       }
       Position p = disasm.getAddressPosition(a.addr);
       if (p == null) continue;
       if (a.breakpoint != null && hidePlantingAnnotation(ann_model, a.breakpoint, p)) continue;
       ann_model.addAnnotation(a, p);
       a.models.add(ann_model);
     }
   }
   // Disassembly editor
   for (TCFAnnotation a : win_info.annotations) {
     if (a.addr == null) continue;
     IEditorPart editor = editors.get(TCFModel.DisassemblyEditorInput.INSTANCE);
     if (editor == null) continue;
     ITCFDisassemblyPart disasm =
         (ITCFDisassemblyPart) editor.getAdapter(ITCFDisassemblyPart.class);
     if (disasm == null) continue;
     IAnnotationModel ann_model = disasm.getAnnotationModel();
     if (ann_model == null) continue;
     if (a.models.contains(ann_model)) {
       ann_model.removeAnnotation(a);
       a.models.remove(ann_model);
     }
     Position p = disasm.getAddressPosition(a.addr);
     if (p == null) continue;
     if (a.breakpoint != null && hidePlantingAnnotation(ann_model, a.breakpoint, p)) continue;
     ann_model.addAnnotation(a, p);
     a.models.add(ann_model);
   }
   // Source editors
   if (set == null) return;
   for (TCFAnnotation a : set) {
     if (a.area == null) continue;
     Object source_element = TCFSourceLookupDirector.lookup(node.launch, a.ctx, a.area);
     if (source_element == null) continue;
     IEditorInput editor_input = presentation.getEditorInput(source_element);
     IEditorPart editor = editors.get(editor_input);
     if (!(editor instanceof ITextEditor)) continue;
     IDocumentProvider doc_provider = ((ITextEditor) editor).getDocumentProvider();
     IAnnotationModel ann_model = doc_provider.getAnnotationModel(editor_input);
     if (ann_model == null) continue;
     IRegion region = null;
     try {
       doc_provider.connect(editor_input);
     } catch (CoreException e) {
     }
     try {
       IDocument document = doc_provider.getDocument(editor_input);
       if (document != null) region = document.getLineInformation(a.area.start_line - 1);
     } catch (BadLocationException e) {
     } finally {
       doc_provider.disconnect(editor_input);
     }
     if (region == null) continue;
     Position p = new Position(region.getOffset(), region.getLength());
     if (a.breakpoint != null && hidePlantingAnnotation(ann_model, a.breakpoint, p)) continue;
     ann_model.addAnnotation(a, p);
     a.models.add(ann_model);
   }
 }