// Licensed to the Apache Software Foundation (ASF) under one
// 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.

[[ugr.tools.ce]]
= Cas Editor User's Guide
// <titleabbrev>Cas Editor User's Guide</titleabbrev>


[[_sandbox.caseditor.introduction]]
== Introduction

The CAS Editor is an Eclipse based annotation tool which supports manual and automatic annotation (via running UIMA annotators) of CASes stored in files.
Currently only text-based CAS are supported.
The CAS Editor can visualize and edit all feature structures.
Feature Structures which are annotations can additionally be viewed and edited directly on text. 


image::images/tools/tools.caseditor/CasEditor.png[]


[[_sandbox.caseditor.launching]]
== Launching the Cas Editor

To open a CAS in the Cas Editor it needs a compatible type system and styling information which specify how to display the types.
The styling information is created automatically by the Cas Editor; but the type system file must be provided by the user. 

A CAS in the xmi or xcas format can simply be opened by clicking on it, like a text file is opened with the Eclipse text editor.

[[_sandbox.caseditor.typesystemspec]]
=== Specifying a type system

The Cas Editor expects a type system file at the root of the project named TypeSystem.xml.
If a type system cannot be found, this message is shown: 


image::images/tools/tools.caseditor/ProvideTypeSystem.png[No type system available for the opened CAS.]

If the type system file does not exist in this location you can point the Cas Editor to a specific type system file.
You can also change the default type system location in the properties page of the Eclipse project.
To do that right click the project, select Properties and go to the UIMA Type System tab, and specify the default location for the type system file. 

After the Cas Editor is opened switch to the Cas Editor Perspective to see all the Cas Editor related views. 

[[_sandbox.caseditor.annotation_editor]]
== Annotation editor

The annotation editor shows the text with annotations and provides different views to show aspects of the CAS. 

[[ugr.tools.cas_editor.annotation_editor.editor]]
=== Editor

After the editor is open it shows the default sofa of the CAS.
(Displaying another sofa is right now not possible.) The editor has an associated, changeable CAS Type.
This type is called the editor "mode". By default the editor only shows annotation of this type.
Actions and views are sensitive to this mode.
The next screen shows the display, where the mode is set to "Person": 


image::images/tools/tools.caseditor/EditorOneType.png[]
				 To change the mode for the editor, use the "Mode" menu in the editor context menu.
To open the context menu right click somewhere on the text. 


image::images/tools/tools.caseditor/ModeMenu.png[]
				        	 The current mode is displayed in the status line at the bottom and in the Style View. 

It's possible to work with more than one annotation type at a time; the mode just selects the default annotation type which can be marked with the fewest keystrokes.
To show annotations of other types, use the "Show" menu in the context menu. 


image::images/tools/tools.caseditor/ShowAnnotationsMenu.png[]
				 Alternatively, you may select the annotation types to be shown in the Style View. 


image::images/tools/tools.caseditor/StyleView2.png[]
 The editor will show the additional selected types. 


image::images/tools/tools.caseditor/EditorAllTypes.png[]
				 The annotation renderer and rendering layer can be changed in the Properties dialog.
After the change all editors which share the same type system will be updated. 

The editor automatically selects annotations of the editor mode type that are near the cursor.
This selection is then synchronized or displayed in other views. 

To create an annotation manually using the editor, mark a piece of text and then press the enter key.
This creates an annotation of the  type of the editor mode, having bounds corresponding to the selection.
You can also use the "Quick Annotate" action from the context menu. 

It is also possible to choose the annotation type; press shift + enter (smart insert) or click on "Annotate" in the context menu for this.
A dialog will ask for the annotation type to create; either select the desired type or use the associated key shortcut.
In the screen shot below, pressing the "p" key will create a Person annotation for "Obama". 


image::images/tools/tools.caseditor/ShiftEnter.png[]

To delete an annotation, select it and press the delete key.
Only annotations of the editor mode can be deleted with this method.
To delete non-editor mode annotations use the Outline View. 

For annotation projects you can change the font size in the editor.
The default font size is 13.
To change this open the Eclipse preference dialog,  go to "UIMA Annotation Editor". 

[[_sandbox.caseditor.annotation_editor.styling]]
=== Configure annotation styling

The Cas Editor can visualize the annotations in multiple highlighting colors and with different annotation drawing styles.
The annotation styling is defined per type system.
When its changed, the appearance changes in all opened editors sharing a type system. 

The styling is initialized with a unique color for every annotation type and every annotation is drawn with Squiggles annotation style.
You may adjust the annotation styles and coloring depending on the project needs. 


image::images/tools/tools.caseditor/StyleView.png[]

The Cas Editor offers a property page to edit the styling.
To open this property page click on the "Properties" button in the Styles view. 

The property page can be seen below.
By clicking on one of the annotation types, the color, drawing style and drawing layer can be edited on the right side. 


image::images/tools/tools.caseditor/StyleProperties.png[]

The annotations can be visualized with one the following  annotation stlyes: 

.Style Table
[cols="1,1,1", frame="all", options="header"]
|===
| Style
| Sample
| Description

|BACKGROUND
|


image::images/tools/tools.caseditor/Style-Background.png[]

|

The background is drawn in the annotation color.

|TEXT_COLOR
|


image::images/tools/tools.caseditor/Style-TextColor.png[]

|

The text is drawn in the annotation color.

|TOKEN
|


image::images/tools/tools.caseditor/Style-Token.png[]

|

The token type assumes that token annotation are always separated by a whitespace.
Only if they are not separated by a whitespace a vertical line is drawn to display the two token annotations.
The image on the left actually contains three annotations, one for "Mr", "." and "Obama". 

|SQUIGGLES
|


image::images/tools/tools.caseditor/Style-Squiggles.png[]

|

Squiggles are drawen under the annotation in the annotation color.

|BOX
|


image::images/tools/tools.caseditor/Style-Box.png[]

|

A box in the annotation color is drawn around the annotation.

|UNDERLINE
|


image::images/tools/tools.caseditor/Style-Underline.png[]

|

A line in the annotation color is drawen below the annotation.

|BRACKET
|


image::images/tools/tools.caseditor/Style-Bracket.png[]

|

An opening bracket is drawn around the first character of the annotation and a closing bracket is drawn around the last character of the annotation.
|===

The Cas Editor can draw the annotations in different layers.
If the spans of two annotations overlap the annotation which is in a higher layer is drawn over annotations in a lower  layer.
Depending on the drawing style it is possible to see both annotations.
The drawing order is defined by the layer number, layer 0 is drawn first, then layer 1 and so on.
If annotations in the same layer overlap its not defined which annotation type is drawn first. 

[[ugr.tools.cas_editor.annotation_editor.cas_views]]
=== CAS view support

The Annotation Editor can only display text Sofa CAS views.
Displaying CAS views with Sofas of different types is not possible and will show an editor page to switch back to another CAS view.
The Edit and Feature Structure Browser views are still available and might be used to edit Feature Structures which belong to the CAS view. 

To switch to another CAS view, right click in the editor to open the context menu and choose "CAS Views" and the view the editor should switch to. 

[[ugr.tools.cas_editor.annotation_editor.outline]]
=== Outline view

The outline view gives an overview of the annoations which are shown in the editor.
The annotation are grouped by type.
There are actions to increase or decrease the bounds of the selected annotation.
There is also an action to merge selected annotations.
The outline has second view mode where only annotations of the current editor mode are shown. 

image::images/tools/tools.caseditor/Outline.png[]
			 
The style can be switched in the view menu, to a style where it only shows the annotations which  belong to the current editor mode. 

[[ugr.tools.cas_editor.annotation_editor.properties_view]]
=== Edit Views

The Edit Views show details about the currently selected annotations or feature structures.
It is possible to change primitive values in this view.
Referenced feature structures can be created and deleted, including arrays.
To link a feature structure with other feature structures, it can be pinned to the edit view.
This means that it does not change if the selection changes. 


image::images/tools/tools.caseditor/EditView.png[]


[[ugr.tools.cas_editor.annotation_editor.fs_view]]
=== FeatureStructure View

The FeatureStructure View lists all feature structures of a specified type.
The type is selected in the type combobox. 

It's possible to create and delete feature structures of every type. 


image::images/tools/tools.caseditor/FSView.png[]


[[ugr.tools.cas_editor.custom_view]]
== Implementing a custom Cas Editor View

Custom Cas Editor views can be added,  to rapidly create, access and/or change Feature Structures in the CAS.
While the Annotation Editor and its views offer support for general viewing and editing, accessing and editing things in the CAS can be streamlined using a custom Cas Editor.
A custom Cas Editor view can be programmed to use a particular type system and optimized to quickly change or show something. 

Annotation projects often need to track the annotation status of a CAS where a user needs to mark which parts have been annotated or corrected.
To do this with the Cas Editor a user would need to use the Feature Structure Browser view to select the Feature Structure and then edit it inside the Edit view.
A custom Cas Editor view could directly select and show the Feature Structure and offer  a tailored user interface to change the annotation status.
Some features such as the name of the annotator could even be automatically filled in. 

The creation of Feature Structures which are linked to existing annotations or Feature Structures is usually difficult with the standard views.
A custom view which can make assumptions about the type system is usually needed to do this efficiently. 

[[ugr.tools.cas_editor.custom_view.sample]]
=== Annotation Status View Sample

The Cas Editor provides the CasEditorView class as a base class for views which need to access the CAS which is opened in the current editor.
It shows a "view not available" message when the current editor does not show a CAS, no editor is opened at all or the current CAS view is incompatible with the view. 

The following snippet shows how it is usually implemented: 

[source]
----
public class AnnotationStatusView extends CasEditorView {
	
  public AnnotationStatusView() {
    super("The Annotation Status View is currently not available.");
  }

  @Override
  protected IPageBookViewPage doCreatePage(ICasEditor editor) {
    ICasDocument document = editor.getDocument();

    if (document != null) {
      return new AnnotationStatusViewPage(editor);
    }

    return null;
  }
}
----

The `doCreatePage` method is called to create the actual view page.
If the document is null the editor failed to load a document and is showing an error message.
In the case the document is not null but the CAS view is incompatible the method should return null to indicate that it has nothing to show.
In this case the "not available" message is displayed. 

The next step is to implement the AnnotationStatusViewPage.
That is the page which gets the CAS as input and need to provide the user with a ui to change the Annotation Status Feature Structure. 

[source]
----
public class AnnotationStatusViewPage extends Page {
  
  private ICasEditor editor;
  
  AnnotationStatusViewPage(ICasEditor editor) {
    this.editor = editor;
  }
  
  ...
  
  public void createControl(Composite parent) {
  
    // create ui elements here
    
    ...
    
    ICasDocument document = editor.getDocument();
    CAS cas = document.getCAS();
    
    // Retrieve Annotation Status FS from CAS
    // and initalize the ui elements with it
    
    FeatureStructre statusFS;
    
    ...
    
    // Add event listeners to the ui element
    // to save an update to the CAS
    // and to advertise a change
    
    ...
    
    // Send update event
    document.update(statusFS);
    
  }
}
----

The above code sketches out how a typical view page is implemented.
The CAS can be directly used to access any Feature Structures or annotations stored in it.
When something is modified added/removed/changed that must be advertised via the ICasDocument object.
It has multiple notification methods which send an event so that other views can be updated.
The view itself can also register a listener to receive CAS change events. 