* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*   http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied.  See the License for the

* specific language governing permissions and limitations

* under the License.

*/

* An editor to annotate text.

*/

 

  private abstract class AbstractAnnotateAction extends Action

      implements ISelectionChangedListener {

 

    public void selectionChanged(SelectionChangedEvent event) {

      setEnabled(AnnotationEditor.this.getSelection().y -

          AnnotationEditor.this.getSelection().x > 0);

    }

  }

 

  /**

   * This action annotates the selected text with a defined tag.

   */

  private class QuickAnnotateAction extends AbstractAnnotateAction {

   

    private static final String ID = "QuickAnnotate";

   

    private StyledText mTextWidget;

    /**

     * Initializes a new instance.

     *

     * @param textWidget

     */

    QuickAnnotateAction(StyledText textWidget) {

      mTextWidget = textWidget;

    }

    /**

     * Executes this action, adds an annotation of the marked span.

     */

    @Override

    public void run() {

      if (isSomethingSelected()) {

        Point selection = mTextWidget.getSelectionRange();

        // get old annotations of current type for this area

        // if there is something ... the delete them and add

        Collection<AnnotationFS> oldAnnotations = getAnnotation(getDocument().getCAS(),

            getAnnotationMode(), new Span(selection.x, selection.y));

        if (!oldAnnotations.isEmpty()) {

          getDocument().removeFeatureStructures(oldAnnotations);

        }

        int start = selection.x;

        int end = start + selection.y;

        AnnotationFS annotation = getDocument().getCAS().createAnnotation(getAnnotationMode(),

                start, end);

        getDocument().addFeatureStructure(annotation);

        setAnnotationSelection(annotation);

      }

    }

    ICasDocument getDocument() {

      return AnnotationEditor.this.getDocument();

    }

  }

  private class SmartAnnotateAction extends AbstractAnnotateAction {

    private static final String ID = "Annotate";

   

    @Override

    public void run() {

      if (isSomethingSelected()) {

        QuickTypeSelectionDialog typeDialog =

          new QuickTypeSelectionDialog(Display.getCurrent().getActiveShell(),

          AnnotationEditor.this);

        typeDialog.open();

      }

    }

  }

  /**

   * Shows the annotation editing context for the active annotation.

   */

  private class ShowAnnotationContextEditAction extends Action {

    private InformationPresenter mPresenter;

    /**

     * Initializes a new instance.

     */

    ShowAnnotationContextEditAction() {

      mPresenter = new InformationPresenter(new AnnotationEditingControlCreator());

      mPresenter.setInformationProvider(new AnnotationInformationProvider(AnnotationEditor.this),

              org.eclipse.jface.text.IDocument.DEFAULT_CONTENT_TYPE);

      mPresenter.setDocumentPartitioning(org.eclipse.jface.text.IDocument.DEFAULT_CONTENT_TYPE);

      mPresenter.install(getSourceViewer());

    }

    /**

     * Executes this action, shows context information.

     */

    @Override

    public void run() {

      mPresenter.showInformation();

      // the information presenter closes ... if

      // the subject control sends a keyDown event

      // this action is triggered with

      // a keyEvent send by the subject control

      // inside this handler the presenter gets installed on

      // the subject control during that the presenter registers

      // a key listener on the subject control

      // the presenter closes now because the keyEvent to trigger

      // this action is also sent to the presenter

      // to avoid this behavior this action is reposted

      // to the END of the ui thread queue

      // this does not happen if for the action is no key explicit

      // configured with setActivationKey(...)

      // TODO:

      // This does not work for mac or linux

    }

  }

   * This <code>IDocumentChangeListener</code> is responsible to synchronize annotation in the

   * document with the annotations in eclipse.

   */

  private class DocumentListener extends AbstractAnnotationDocumentListener {

   

    /**

     * Adds a collection of annotations.

     *

     * @param annotations

     */

    @Override

    public void addedAnnotation(Collection<AnnotationFS> annotations) {

      IAnnotationModelExtension annotationModel = (IAnnotationModelExtension) getDocumentProvider().getAnnotationModel(getEditorInput());

     

      Map<Annotation, Position> addAnnotationMap = new HashMap<Annotation, Position>();

     

      for (AnnotationFS annotation : annotations) {

        addAnnotationMap.put(new EclipseAnnotationPeer(annotation), new Position(annotation.getBegin(),

                annotation.getEnd() - annotation.getBegin()));

      }

     

      annotationModel.replaceAnnotations(null, addAnnotationMap);

    }

    /**

     * Removes a collection of annotations.

     *

     * @param deletedAnnotations

     */

    @Override

    public void removedAnnotation(Collection<AnnotationFS> deletedAnnotations) {

      if (getSite().getPage().getActivePart() == AnnotationEditor.this) {

        mFeatureStructureSelectionProvider.clearSelection();

      } else {

        mFeatureStructureSelectionProvider.clearSelectionSilently();

      }

      highlight(0, 0); // TODO: only if removed annotation was selected

      IAnnotationModelExtension annotationModel = (IAnnotationModelExtension) getDocumentProvider().getAnnotationModel(getEditorInput());

     

      Annotation removeAnnotations[] = new Annotation[deletedAnnotations.size()];

      int removeAnnotationsIndex = 0;

      for (AnnotationFS annotation : deletedAnnotations) {

        removeAnnotations[removeAnnotationsIndex++] = new EclipseAnnotationPeer(annotation);

      }

     

      annotationModel.replaceAnnotations(removeAnnotations, null);

    }

    /**

     *

     * @param annotations

     */

    @Override

    public void updatedAnnotation(Collection<AnnotationFS> annotations) {

     

      IAnnotationModelExtension annotationModel = (IAnnotationModelExtension) getDocumentProvider().getAnnotationModel(getEditorInput());

     

      for (AnnotationFS annotation : annotations) {

        annotationModel.modifyAnnotationPosition(new EclipseAnnotationPeer(annotation),

                new Position(annotation.getBegin(), annotation.getEnd() - annotation.getBegin()));

      }

     

      selectionChanged(getSite().getPage().getActivePart(), mFeatureStructureSelectionProvider.getSelection());

    }

    public void changed() {

      mFeatureStructureSelectionProvider.clearSelection();

      syncAnnotations();

    }

   

    public void viewChanged(String oldViewName, String newViewName) {

      // TODO: Currently do nothing ...

    }

  }

  /**

   * Sometimes the wrong annotation is selected ... ????

   */

  private class FeatureStructureDragListener implements DragSourceListener {

    private boolean mIsActive;

    private AnnotationFS mCandidate;

    FeatureStructureDragListener(final StyledText textWidget) {

      textWidget.addKeyListener(new KeyListener() {

        public void keyPressed(KeyEvent e) {

          if (e.keyCode == SWT.ALT) {

            mIsActive = true;

            textWidget.setCursor(Display.getCurrent().getSystemCursor(SWT.CURSOR_HAND));

          }

        }

        public void keyReleased(KeyEvent e) {

          if (e.stateMask == SWT.ALT) {

            mIsActive = false;

            textWidget.setCursor(null);

          }

        }

      });

      textWidget.addMouseMoveListener(new MouseMoveListener() {

        public void mouseMove(MouseEvent e) {

          if (mIsActive) {

            // try to get the position inside the text

            int offset;

            // Workaround: It is possible check that is text under the cursor ?

            try {

              offset = textWidget.getOffsetAtLocation(new Point(e.x, e.y));

            }

            catch (IllegalArgumentException e2) {

              return;

            }

            Map<Integer, AnnotationFS> view = getView(getAnnotationMode());

            mCandidate = view.get(offset);

            if (mCandidate != null) {

              textWidget.setSelectionRange(mCandidate.getBegin(), mCandidate.getEnd()

                      - mCandidate.getBegin());

            }

          }

        }

      });

    }

    public void dragStart(DragSourceEvent event) {

      if (mIsActive) {

        event.doit = mCandidate != null;

      } else {

        event.doit = false;

      }

    }

    public void dragSetData(DragSourceEvent event) {

      event.data = mCandidate;

    }

    public void dragFinished(DragSourceEvent event) {

    }

  }

  private class AnnotationAccess implements IAnnotationAccess, IAnnotationAccessExtension {

    public Object getType(Annotation annotation) {

      return null;

    }

    public boolean isMultiLine(Annotation annotation) {

      return false;

    }

    public boolean isTemporary(Annotation annotation) {

      return false;

    }

    public int getLayer(Annotation annotation) {

      if (annotation instanceof EclipseAnnotationPeer) {

        EclipseAnnotationPeer eclipseAnnotation = (EclipseAnnotationPeer) annotation;

        // ask document provider for this

        // getAnnotation must be added to cas document provider

        AnnotationStyle style = getAnnotationStyle(

            eclipseAnnotation.getAnnotationFS().getType());

        return style.getLayer();

      }

      else {

        return 0;

      }

    }

    public Object[] getSupertypes(Object annotationType) {

      return new Object[0];

    }

    public String getTypeLabel(Annotation annotation) {

      return null;

    }

    public boolean isPaintable(Annotation annotation) {

      assert false : "Should never be called";

      return false;

    }

    /**

     * This implementation imitates the behavior without the

     * {@link IAnnotationAccessExtension}.

     */

    public boolean isSubtype(Object annotationType, Object potentialSupertype) {

      Type type = getDocument().getCAS().getTypeSystem().getType((String) annotationType);

      return mShowAnnotationsMenu.getSelectedTypes().contains(type) ||

          getAnnotationMode().equals(type);

    }

    public void paint(Annotation annotation, GC gc, Canvas canvas, Rectangle bounds) {

      assert false : "Should never be called";

    }

  }

  // TODO: Move to external class

  static class CasViewMenu extends ContributionItem {

   

    private AnnotationEditor casEditor;

   

    public CasViewMenu(AnnotationEditor casEditor) {

      this.casEditor = casEditor;

    }

   

    @Override

    public void fill(Menu parentMenu, int index) {

     

      CAS cas = casEditor.getDocument().getCAS();

     

      for (Iterator<CAS> it = cas.getViewIterator(); it.hasNext(); ) {

       

        CAS casView = it.next();

        final String viewName = casView.getViewName();

       

        final MenuItem actionItem = new MenuItem(parentMenu, SWT.CHECK);

        actionItem.setText(viewName);

       

        // TODO: Disable non-text views, check mime-type

        try {

          actionItem.setEnabled(cas.getDocumentText() != null);

        } catch (Throwable t) {

          // TODO: Not nice, discuss better solution on ml

          actionItem.setEnabled(false);

        }

       

        // TODO: Add support for non text views, editor has

        //       to display some error message

       

        if (cas.getViewName().equals(viewName))

            actionItem.setSelection(true);

       

        // TODO: move this to an action

        actionItem.addListener(SWT.Selection, new Listener() {

          public void handleEvent(Event e) {

            // Trigger only if view is really changed

            // TODO: Move this check to the document itself ...

            if(!casEditor.getDocument().getCAS().getViewName().equals(viewName)) {

                casEditor.showView(viewName);

            }

          }

        });

      }

    }

  }

 

  private Type mAnnotationMode;

  /**

   * The outline page belonging to this editor.

   */

  private OutlinePageBook mOutlinePage = new OutlinePageBook();

  private Set<IAnnotationEditorModifyListener> mEditorListener = new HashSet<IAnnotationEditorModifyListener>();

  private ListenerList mEditorInputListener = new ListenerList();

 

  /**

   * TODO: Do we really need this position variable ?

   */

  private int mCursorPosition;

  boolean mIsSomethingHighlighted = false;

  private StyleRange mCurrentStyleRange;

  private FeatureStructureSelectionProvider mFeatureStructureSelectionProvider;

  private AnnotationPainter mPainter;

  private ShowAnnotationsMenu mShowAnnotationsMenu;

  private DocumentListener mAnnotationSynchronizer;

  private AnnotationStyleChangeListener mAnnotationStyleListener;

 

  private Collection<Type> shownAnnotationTypes = new HashSet<Type>();

 

  private IPropertyChangeListener preferenceStoreChangeListener;

 

  private CasDocumentProvider casDocumentProvider;

  /**

   * Creates an new AnnotationEditor object.

   */

  public AnnotationEditor() {

  }

  @Override

  public void init(IEditorSite site, IEditorInput input) throws PartInitException {

    casDocumentProvider =

            CasDocumentProviderFactory.instance().getDocumentProvider(input);

   

    setDocumentProvider(new TextDocumentProvider(casDocumentProvider));

    super.init(site, input);

  }

 

  public CasDocumentProvider getCasDocumentProvider() {

    return casDocumentProvider;

  }

 

  /**

   * Retrieves the tooltip of the title.

   *

   * @return string of tooltip

   */

  @Override

  public String getTitleToolTip() {

    if (getEditorInput() == null) {

      return super.getTitleToolTip();

    }

    ICasDocument document = getDocument();

    if(document == null) {

      return super.getTitleToolTip();

    }

    String typeSystemText = document.getTypeSystemText();

    String toolTipText = getEditorInput().getToolTipText();

    if (typeSystemText != null) {

      return toolTipText + " (" + typeSystemText + ")";

    } else {

      return toolTipText;

    }

  }

 

  /**

   * Retrieves annotation editor adapters.

   *

   * @param adapter

   * @return an adapter or null

   */

  @Override

  public Object getAdapter(@SuppressWarnings("rawtypes") Class adapter) {

    if (IContentOutlinePage.class.equals(adapter) && getDocument() != null) {

      return mOutlinePage;

    }

    else if (CAS.class.equals(adapter) && getDocument() != null) {

      return getDocument().getCAS();

    }

    else {

      return super.getAdapter(adapter);

    }

  }

  @Override

  protected ISourceViewer createSourceViewer(Composite parent,

          org.eclipse.jface.text.source.IVerticalRuler ruler, int styles) {

    SourceViewer sourceViewer = new SourceViewer(parent, ruler, styles);

    sourceViewer.setEditable(false);

    mPainter = new AnnotationPainter(sourceViewer, new AnnotationAccess());

    sourceViewer.addPainter(mPainter);

   

    return sourceViewer;

  }

  private void setTextSize(int newSize) {

    Font font = getSourceViewer().getTextWidget().getFont();

   

    if (font.getFontData().length > 0) {

      FontData fd = font.getFontData()[0];

      getSourceViewer().getTextWidget().setFont(new Font(font.getDevice(),

              fd.getName(), newSize, fd.getStyle()));

    }

  }

 

  /**

   * Configures the editor.

   *

   * @param parent

   */

  @Override

  public void createPartControl(Composite parent) {

    super.createPartControl(parent);

    /*

     * this is a workaround for the quickdiff assertion if nothing was changed, how to do this

     * better ? is this the right way ?

     */

    showChangeInformation(false);

    // UIMA-2167:

    // The Annotation Editor needs to listen to changes for the caret position,

    // the new eclipse 3.5 API allows to register a listener which reports

    // that

    //

    // Until this can be used we improvise by registering a couple of listeners which

    // compute a caret offset change based on events which could change it,

    // that are key and mouse listeners.

   

    getSourceViewer().getTextWidget().addKeyListener(new KeyListener() {

      public void keyPressed(KeyEvent e) {

        int newCaretOffset = getSourceViewer().getTextWidget().getCaretOffset();

        if (newCaretOffset != mCursorPosition) {

          mCursorPosition = newCaretOffset;

          refreshSelection();

        }

      }

      public void keyReleased(KeyEvent e) {

        // not implemented

      }

    });

    getSourceViewer().getTextWidget().addMouseListener(new MouseListener() {

      public void mouseDown(MouseEvent e) {

        int newCaretOffset = getSourceViewer().getTextWidget().getCaretOffset();

        if (newCaretOffset != mCursorPosition) {

          mCursorPosition = newCaretOffset;

          refreshSelection();

        }

      }

      public void mouseDoubleClick(MouseEvent e) {

        // not needed

      }

      public void mouseUp(MouseEvent e) {

        int newCaretOffset = getSourceViewer().getTextWidget().getCaretOffset();

       

        if (newCaretOffset != mCursorPosition) {

          mCursorPosition = newCaretOffset;

          refreshSelection();

        }       

      }

    });

   

    // UIMA-2242:

    // When a single character is selected with a double click the selection

    // changes but the caret does not.

    // A press on enter now fails to create an annotation.

   

    // UIMA-2247:

    // Changed again to ensure that also selection from the find dialog

    // can be detected

    getSourceViewer().getSelectionProvider().addSelectionChangedListener(new ISelectionChangedListener() {

      public void selectionChanged(SelectionChangedEvent event) {

        mFeatureStructureSelectionProvider.setSelection(new AnnotationEditorSelection((ITextSelection) event.getSelection(),

                new StructuredSelection(ModelFeatureStructure.create(getDocument(), getSelectedAnnotations()))));

      }

    });

   

    DragSource dragSource = new DragSource(getSourceViewer().getTextWidget(), DND.DROP_COPY);

    Transfer[] types = new Transfer[] { FeatureStructureTransfer.getInstance() };

    dragSource.setTransfer(types);

    dragSource.addDragListener(new FeatureStructureDragListener(getSourceViewer().getTextWidget()));

    getSourceViewer().getTextWidget().setEditable(false);

    getSourceViewer().setEditable(false);

    getSite().setSelectionProvider(mFeatureStructureSelectionProvider);

   

     

    // Retrieve font size from preference store, default is 15

    IPreferenceStore prefStore = CasEditorPlugin.getDefault().getPreferenceStore();

    int textSize = prefStore.getInt(AnnotationEditorPreferenceConstants.ANNOTATION_EDITOR_TEXT_SIZE);

   

    if (textSize > 0) {

      setTextSize(textSize);

    }

   

    preferenceStoreChangeListener = (new IPropertyChangeListener() {

     

      public void propertyChange(PropertyChangeEvent event) {

        if (AnnotationEditorPreferenceConstants.ANNOTATION_EDITOR_TEXT_SIZE.equals(event.getProperty())) {

          Integer textSize = (Integer) event.getNewValue();

         

          if (textSize != null && textSize > 0) {

            setTextSize(textSize);

          }

        }

      }

    });

   

    prefStore.addPropertyChangeListener(preferenceStoreChangeListener);

   

    // Note: In case the CAS could not be created the editor will be initialized with

    // a null document (getDocument() == null). Depending on the error it might be

    // possible to recover and the editor input will be set again. The createPartControl

    // method might be called with a document or without one, both cases must be supported.

   

    // Perform the document dependent initialization

    initiallySynchronizeUI();

  }

  private void refreshSelection() {

    mFeatureStructureSelectionProvider.setSelection(getDocument(), getSelectedAnnotations());

  }

  /**

   * Checks if the current instance is editable.

   *

   * @return false

   */

  @Override

  public boolean isEditable() {

    return false;

  }

 

  /**

   * Used to inform about input changes

   *

   * @param parent

   */

  @Override

  protected void handleElementContentReplaced() {

    super.handleElementContentReplaced();

    setInput(getEditorInput());

  }

 

  @Override

  protected void doSetInput(final IEditorInput input) throws CoreException {

    final IEditorInput oldInput = getEditorInput();

    final ICasDocument oldDocument = getDocument();

   

    // Unregister the editor listeners on the old input

    // TODO: Should we make methods to encapsulate the register/unregister code?

    if (oldDocument != null) {

      oldDocument.removeChangeListener(mAnnotationSynchronizer);

      mAnnotationSynchronizer = null;

     

      getCasDocumentProvider().getTypeSystemPreferenceStore(getEditorInput()).

              removePropertyChangeListener(mAnnotationStyleListener);

      mAnnotationStyleListener = null;

    }

    super.doSetInput(input);

   

    if (CasEditorPlugin.getDefault().

            getAndClearShowMigrationDialogFlag()) {

      getSite().getShell().getDisplay().asyncExec(new Runnable() {

          public void run() {

              MessageDialog.openInformation(getSite().getShell(),"Cas Editor Project Removed",

                      "The Cas Editor Project support was removed from this release and" +

                      " your existing Cas Editor Projects have been migrated. If you still want to use the " +

                      "Cas Editor Project support please install the Cas Editor 2.3.1 again.\n\n" +

                      "The Analysis Engine and Cas Consumer run support was also removed and " +

                      "is replaced by the new Analysis Engine Launch plugin.");

          }

      });

    }

   

    if (getDocument() != null) {

     

      AnnotationOutline outline = new AnnotationOutline(this);

      mOutlinePage.setCASViewPage(outline);

      shownAnnotationTypes.clear();

     

      // Synchronize shown types with the editor

      String shownTypesString = getCasDocumentProvider().getSessionPreferenceStore(input).getString("LastShownTypes");

     

      String[] shownTypes = shownTypesString.split(";");

     

      for (String shownType : shownTypes) {

       

        Type type = getDocument().getType(shownType);

       

        // Types can be deleted from the type system but still be marked

        // as shown in the .dotCorpus file, in that case the type

        // name cannot be mapped to a type and should be ignored.

       

        if (type != null)

          shownAnnotationTypes.add(type);

      }

     

      if (getSourceViewer() != null) {

       

        // This branch is usually only executed when the

        // input was updated because it could not be opened the

        // first time trough an error e.g. no type system available

        //

        // Compared to the usual code branch createPartControl was

        // already called without a document, which means

        // that the state between the UI and the document

        // must be synchronized now

        initiallySynchronizeUI();

        // Views which fetch content from the editors document still believe

        // the editor document is not available.

        // Send a partBroughtToTop event to the views to update their content

        // on this currently active editor.

        IWorkbenchPage page = getSite().getWorkbenchWindow().getActivePage();

       

        for (IWorkbenchPart view : page.getViews()) {

          if (view instanceof PageBookView) {

            ((PageBookView) view).partBroughtToTop(getEditorSite().getPart());

          }

        }

      }

    }

    else {

      // Makes the outline book show the not available message page

      mOutlinePage.setCASViewPage(null);

    }

   

    final ICasDocument newDocument = getDocument();

   

    if (mEditorInputListener != null) {

     

      // Iterate over the existing listeners, listeners might be removed

      // or added during notification, since views are created or destroyed

      // when this event is fired.

     

      for (Object listener : mEditorInputListener.getListeners()) {

       

        final ICasEditorInputListener inputListener =

                (ICasEditorInputListener) listener;

       

        SafeRunner.run(new SafeRunnable() {

          public void run() {

            inputListener.casDocumentChanged(oldInput, oldDocument, input, newDocument);

          }

        });

      }

    }

  }

  // The editor status support is abused to display different control than the

  // text control when displaying text is not possible, e.g. because the sofa

  // is not a text sofa or not set at all

  @Override

  protected boolean isErrorStatus(IStatus status) {

    return super.isErrorStatus(status) || getDocument().getCAS().getDocumentText() == null;

  }

 

  /**

   * Initialized the UI from the freshly set document.

   *

   * Note: Does nothing if getDoucment() return null.

   */

  private void initiallySynchronizeUI() {

    if (getDocument() != null) {

     

      mShowAnnotationsMenu = new ShowAnnotationsMenu(

              getDocument().getCAS().getTypeSystem(), shownAnnotationTypes);

      mShowAnnotationsMenu.addListener(new IShowAnnotationsListener() {

        public void selectionChanged(Collection<Type> selection) {

         

          // if changes selection is either larger, or smaller

          // if larger an annotation type was added

          // if smaller one was removed

          if (shownAnnotationTypes.size() < selection.size()) {

            List<Type> clonedCollection = new ArrayList<Type>(selection);

            clonedCollection.removeAll(shownAnnotationTypes);

           

            Type addedAnnotationType = clonedCollection.get(0);

            showAnnotationType(addedAnnotationType, true);

          }

          else if (selection.size() < shownAnnotationTypes.size()) {

            List<Type> clonedCollection = new ArrayList<Type>(shownAnnotationTypes);

            clonedCollection.removeAll(selection);

           

            Type removedAnnotationType = clonedCollection.get(0);

            showAnnotationType(removedAnnotationType, false);

          }

         

          // Repaint after annotations are changed

          mPainter.paint(IPainter.CONFIGURATION);

         

          setEditorSessionPreferences();

         

          if (mEditorListener != null) {

            for (IAnnotationEditorModifyListener listener : mEditorListener)

              listener.showAnnotationsChanged(selection);

          }

        }

      });

     

      IPreferenceStore sessionPreferences =

          getCasDocumentProvider().getSessionPreferenceStore(getEditorInput());

     

      // TODO: Define constants for these settings!

     

      Type annotationModeType = getDocument().getType(

          sessionPreferences.getString("LastUsedModeType"));

     

      // Note: The type in the configuration might not exist anymore, or there is

      // no type stored yet, in these cases the built-in uima.tcas.Annotation type is used.

      // Not setting the annotation type will cause NPEs after the editor opened.

     

      if (annotationModeType == null) {

        annotationModeType = getDocument().getType(CAS.TYPE_NAME_ANNOTATION);

      }

     

      setAnnotationMode(annotationModeType);

     

      String lastActiveViewName = sessionPreferences.getString("LastActiveCasViewName");

     

      try {

        // TODO: Missing compatibility check!!!

        getDocument().getCAS().getView(lastActiveViewName);

        showView(lastActiveViewName);

      }

      catch (CASRuntimeException e) {

        // ignore, view is not available

        // Note: Using exceptions for control flow is very bad practice

        // TODO: Is there a way to check which views are available?!

        //       Maybe we should iterate over all available views, and then

        //       check if it is available!

        showView(CAS.NAME_DEFAULT_SOFA);

      }

    }

  }

 

  @Override

  protected void editorContextMenuAboutToShow(IMenuManager menu) {

    super.editorContextMenuAboutToShow(menu);

    // Add Annotate action

    menu.appendToGroup(IWorkbenchActionConstants.MB_ADDITIONS, new Separator());

    menu.appendToGroup(IWorkbenchActionConstants.MB_ADDITIONS, getAction(SmartAnnotateAction.ID));

    menu.appendToGroup(IWorkbenchActionConstants.MB_ADDITIONS, getAction(QuickAnnotateAction.ID));

    menu.appendToGroup(IWorkbenchActionConstants.MB_ADDITIONS, getAction(ITextEditorActionDefinitionIds.DELETE));

   

    TypeSystem typeSytem = getDocument().getCAS().getTypeSystem();

    // mode menu

    MenuManager modeMenuManager = new MenuManager("Mode");

    menu.appendToGroup(IWorkbenchActionConstants.MB_ADDITIONS, modeMenuManager);

    ModeMenu modeMenu = new ModeMenu(typeSytem, this);

    modeMenu.addListener(new IModeMenuListener(){

    public void modeChanged(Type newMode) {

      IAction actionToExecute = new ChangeModeAction(newMode, newMode.getShortName(),

              AnnotationEditor.this);

      actionToExecute.run();

    }});

    modeMenuManager.add(modeMenu);

    // annotation menu

    MenuManager showAnnotationMenu = new MenuManager("Show Annotations");

    menu.appendToGroup(IWorkbenchActionConstants.MB_ADDITIONS, showAnnotationMenu);

    showAnnotationMenu.add(mShowAnnotationsMenu);

   

    // view menu

    MenuManager casViewMenuManager = new MenuManager("CAS Views");

    menu.appendToGroup(IWorkbenchActionConstants.MB_ADDITIONS, casViewMenuManager);

    CasViewMenu casViewMenu = new CasViewMenu(this);

    casViewMenuManager.add(casViewMenu);

  }

  /**

   * Updates the status line.

   */

  private void updateStatusLineModeItem() {

    // TODO: refactore this

    IStatusField statusField = getStatusField(AnnotationEditorActionContributor.ID);

    // can be null directly after doSetInput()

    if (statusField != null) {

      statusField.setText(getAnnotationMode().getShortName());

    }

  }

  /**

   * Returns the current <code>AnnotationDocument</code> of this editor.

   *

   * @return current <code>AnnotationDocument</code>

   */

  public ICasDocument getDocument() {

    return (ICasDocument) getDocumentProvider().getDocument(getEditorInput());

  }

  public void reopenEditorWithNewTypeSystem() {

    setInput(getEditorInput());

  }

 

  /**

   * Returns the current annotation type.

   *

   * @return - current annotation type

   */

  public Type getAnnotationMode() {

    return mAnnotationMode;

  }

  /**

   * Sets the new annotation type.

   *

   * @param type

   */

  public void setAnnotationMode(Type type) {

    // TODO: check if this type is a subtype of Annotation

    if (type == null) {

      throw new IllegalArgumentException("type must not be null!");

    }

    mAnnotationMode = type;

    highlight(0, 0);

    setEditorSessionPreferences();

    updateStatusLineModeItem();

    syncAnnotationTypes();

    fireAnnotationTypeChanged(getAnnotationMode());

    mShowAnnotationsMenu.setEditorAnnotationMode(type);

  }

  public Collection<Type> getShownAnnotationTypes() {

    return Collections.unmodifiableCollection(shownAnnotationTypes);

  }

 

  public void setShownAnnotationType(Type type, boolean isShown) {

    mShowAnnotationsMenu.setSelectedType(type, isShown);

  }

  /**

   * @param type

   */

  private void fireAnnotationTypeChanged(Type type) {

    if (mEditorListener != null) {

      for (IAnnotationEditorModifyListener listener : mEditorListener)

        listener.annotationModeChanged(type);

    }

  }

  /**

   * Retrieves an <code>AnnotationStyle</code> from the underlying storage.

   *

   * @param element

   * @param type

   * @return

   */

  public AnnotationStyle getAnnotationStyle(Type type) {

    if (type == null)

      throw new IllegalArgumentException("type parameter must not be null!");

   

    IPreferenceStore prefStore = getCasDocumentProvider().

            getTypeSystemPreferenceStore(getEditorInput());

   

    return AnnotationStyle.getAnnotationStyleFromStore(prefStore, type.getName());

  }

 

  /**

   * Sets an annotation style.

   *

   * Note: Internal usage only!

   *

   * @param element

   * @param style

   */

  // TODO: Disk must be accessed for every changed annotation style

  // add a second method which can take all changed styles

  public void setAnnotationStyle(AnnotationStyle style) {

    IPreferenceStore prefStore = getCasDocumentProvider().getTypeSystemPreferenceStore(getEditorInput());

    AnnotationStyle.putAnnotatationStyleToStore(prefStore, style);

   

    getCasDocumentProvider().saveTypeSystemPreferenceStore(getEditorInput());

  }

 

  /**

   * Set the shown annotation status of a type.

   *

   * @param type

   * @param isVisible if true the type is shown, if false the type

   * it not shown

   */

  private void showAnnotationType(Type type, boolean isVisible) {

    AnnotationStyle style = getAnnotationStyle(type);

   

    if (isVisible) {

     

      IDrawingStrategy strategy = DrawingStyle.createStrategy(style);

     

      // It might not be possible to create the drawing strategy trough

      // configuration errors, in this case the drawing strategy will be ignored

      if (strategy != null) {

       

        if (style.getStyle().equals(AnnotationStyle.Style.TAG)) {

          getSourceViewer().getTextWidget().setLineSpacing(13);

        }

       

        mPainter.addDrawingStrategy(type.getName(), strategy);

        mPainter.addAnnotationType(type.getName(), type.getName());

        java.awt.Color color = style.getColor();

        mPainter.setAnnotationTypeColor(type.getName(), new Color(null, color.getRed(),

                color.getGreen(), color.getBlue()));

      }

     

      shownAnnotationTypes.add(type);

    }

    else {

      mPainter.removeAnnotationType(type.getName());

      shownAnnotationTypes.remove(type);

     

      if (style.getStyle().equals(AnnotationStyle.Style.TAG)) {

        // TODO: only if no more TAG styles are active

        // How to figure that out ?!

        boolean isKeepLineSpacing = false;

       

        for(Type shownType : shownAnnotationTypes) {

          AnnotationStyle potentialTagStyle = getAnnotationStyle(shownType);

         

          if (AnnotationStyle.Style.TAG.equals(potentialTagStyle.getStyle())) {

            isKeepLineSpacing = true;

            break;

          }

        }

       

        if (!isKeepLineSpacing)

          getSourceViewer().getTextWidget().setLineSpacing(0);

      }

    }

  }

  /**

   * Synchronizes all annotations with the eclipse annotation painter.

   */

  public void syncAnnotationTypes() {

    mPainter.removeAllAnnotationTypes();

    getSourceViewer().getTextWidget().setLineSpacing(0);

   

    for (Type displayType : mShowAnnotationsMenu.getSelectedTypes()) {

      showAnnotationType(displayType, true);

    }

    if (!mShowAnnotationsMenu.getSelectedTypes().contains(getAnnotationMode())) {

      showAnnotationType(getAnnotationMode(), true);

    }

    mPainter.paint(IPainter.CONFIGURATION);

  }

  private void removeAllAnnotations() {

    // Remove all annotation from the model

    IAnnotationModel annotationModel = getDocumentProvider().getAnnotationModel(getEditorInput());

    ((IAnnotationModelExtension) annotationModel).removeAllAnnotations();

  }

 

  private void syncAnnotations() {

   

    removeAllAnnotations();

   

    // Remove all annotation from the model

    IAnnotationModel annotationModel = getDocumentProvider().getAnnotationModel(getEditorInput());

    ((IAnnotationModelExtension) annotationModel).removeAllAnnotations();

   

    // Add all annotation to the model

    // copy annotations into annotation model

    final Iterator<AnnotationFS> mAnnotations = getDocument().getCAS().getAnnotationIndex()

            .iterator();

   

    // TODO: Build first a map, and then pass all annotations at once

    Map annotationsToAdd = new HashMap();

   

    while (mAnnotations.hasNext()) {

      AnnotationFS annotationFS = mAnnotations.next();

      annotationsToAdd.put(new EclipseAnnotationPeer(annotationFS), new Position(

              annotationFS.getBegin(), annotationFS.getEnd() - annotationFS.getBegin()));

    }

   

    ((IAnnotationModelExtension) annotationModel).replaceAnnotations(null, annotationsToAdd);

  }

 

  /**

   * @param listener

   */

  public void addAnnotationListener(IAnnotationEditorModifyListener listener) {

    mEditorListener.add(listener);

  }

 

  public void removeAnnotationListener(IAnnotationEditorModifyListener listener) {