/*
* 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.
*/
package org.apache.uima.ruta.check;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.apache.uima.UIMAFramework;
import org.apache.uima.cas.CAS;
import org.apache.uima.cas.Feature;
import org.apache.uima.cas.Type;
import org.apache.uima.cas.TypeSystem;
import org.apache.uima.cas.impl.XmiCasDeserializer;
import org.apache.uima.cas.text.AnnotationFS;
import org.apache.uima.caseditor.editor.AnnotationEditor;
import org.apache.uima.resource.ResourceInitializationException;
import org.apache.uima.resource.metadata.FsIndexDescription;
import org.apache.uima.resource.metadata.TypeSystemDescription;
import org.apache.uima.ruta.addons.RutaAddonsPlugin;
import org.apache.uima.util.CasCreationUtils;
import org.apache.uima.util.InvalidXMLException;
import org.apache.uima.util.XMLInputSource;
import org.eclipse.core.resources.IFile;
import org.eclipse.jface.dialogs.IInputValidator;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.jface.viewers.TreeSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.DropTargetAdapter;
import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.dnd.FileTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.FormAttachment;
import org.eclipse.swt.layout.FormData;
import org.eclipse.swt.layout.FormLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.ui.part.ViewPart;
import org.xml.sax.SAXException;
public class AnnotationCheckComposite extends Composite implements ISelectionChangedListener,
ISelectionListener {
private CheckAnnotationDocumentListener annotationListener;
private AnnotationCheckTreeNodeComparator comparator = new AnnotationCheckTreeNodeComparator();
private AnnotationCheckLabelProvider lableProvider;
private TreeViewer treeView;
private Text documentSource;
private ViewPart viewPart;
private Text pathToTypeSystem;
private HashMap<String, Image> images;
private Text documentSink;
private Map<String, Set<String>> typesToCheck;
private Set<String> typesToTransferUnchecked;
private CheckDocument currentDocument = null;
private String annotationMode;
private AnnotationEditor casEditor;
private List<CheckDocument> oldDocs;
private TypeSystemDescription tsd;
public AnnotationCheckComposite(Composite parent, int style, ViewPart viewPart) {
super(parent, style);
this.viewPart = viewPart;
typesToCheck = new HashMap<String, Set<String>>();
typesToTransferUnchecked = new HashSet<String>();
initGui();
annotationListener = new CheckAnnotationDocumentListener(this);
}
private void initGui() {
this.setLayout(new FormLayout());
this.setSize(400, 800);
initDocumentSourceTextField();
initDocumentSinkTextField();
initTypeSystemPathTextField();
initTreeViewer();
viewPart.getSite().getPage().addSelectionListener(this);
viewPart.getSite().setSelectionProvider(treeView);
}
private void initTreeViewer() {
FormData fdata3 = new FormData();
fdata3.left = new FormAttachment(0, 1000, 3);
fdata3.top = new FormAttachment(0, 1000, 81);
fdata3.right = new FormAttachment(1000, 1000, -3);
fdata3.bottom = new FormAttachment(1000, 1000, -3);
Composite comp = new Composite(this, SWT.CENTER);
comp.setLayoutData(fdata3);
comp.setLayout(new FillLayout());
treeView = new TreeViewer(comp, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
AnnotationCheckContentProvider provider = new AnnotationCheckContentProvider();
treeView.setContentProvider(provider);
treeView.getControl().addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
char c = e.character;
if (c == '4' || c == '5') {
if (c == '4') {
accept();
} else if (c == '5') {
reject(true);
}
}
}
});
treeView.setComparator(new FeatureCheckTreeNodeComparator());
treeView.getTree().addMouseListener(new MouseAdapter() {
@Override
public void mouseDown(MouseEvent e) {
Object source = e.getSource();
if (source instanceof Tree && e.button == 3) {
Tree tree = (Tree) source;
Composite composite = tree.getParent().getParent();
TreeSelection teeSelection = (TreeSelection) treeView.getSelection();
Object node = teeSelection.getFirstElement();
Display display = Display.getDefault();
Shell shell = new Shell(display, SWT.RESIZE | SWT.APPLICATION_MODAL | SWT.DIALOG_TRIM);
if (node instanceof AnnotationCheckTreeNode && !(node instanceof FeatureCheckTreeNode)) {
changeType(shell, composite, node);
}
if (node instanceof AnnotationCheckTreeNode && node instanceof FeatureCheckTreeNode) {
changeFeature(shell, node);
}
}
}
});
lableProvider = new AnnotationCheckLabelProvider(this);
treeView.setLabelProvider(lableProvider);
}
private void initTypeSystemPathTextField() {
pathToTypeSystem = new Text(this, SWT.SINGLE | SWT.BORDER);
FormData fdata2 = new FormData();
fdata2.width = 200;
fdata2.left = new FormAttachment(0, 1000, 5);
fdata2.top = new FormAttachment(0, 1000, 55);
fdata2.right = new FormAttachment(1000, 1000, -5);
pathToTypeSystem.setLayoutData(fdata2);
pathToTypeSystem.setToolTipText("Type System...");
pathToTypeSystem.setMessage("Type System...");
DropTarget dt1 = new DropTarget(pathToTypeSystem, DND.DROP_DEFAULT | DND.DROP_MOVE);
dt1.setTransfer(new Transfer[] { FileTransfer.getInstance() });
dt1.addDropListener(new DropTargetAdapter() {
@Override
public void drop(DropTargetEvent event) {
String fileList[] = null;
FileTransfer ft = FileTransfer.getInstance();
if (ft.isSupportedType(event.currentDataType)) {
fileList = (String[]) event.data;
}
if (fileList != null && fileList.length > 0) {
String fileString = fileList[0];
pathToTypeSystem.setText(fileString);
}
}
});
}
private void initDocumentSinkTextField() {
documentSink = new Text(this, SWT.SINGLE | SWT.BORDER);
FormData fdatag = new FormData();
fdatag.width = 200;
fdatag.left = new FormAttachment(0, 1000, 5);
fdatag.top = new FormAttachment(0, 1000, 30);
fdatag.right = new FormAttachment(1000, 1000, -5);
documentSink.setLayoutData(fdatag);
documentSink.setToolTipText("Document gold output folder...");
documentSink.setMessage("Document gold output folder...");
DropTarget dtg = new DropTarget(documentSink, DND.DROP_DEFAULT | DND.DROP_MOVE);
dtg.setTransfer(new Transfer[] { FileTransfer.getInstance() });
dtg.addDropListener(new DropTargetAdapter() {
@Override
public void drop(DropTargetEvent event) {
String fileList[] = null;
FileTransfer ft = FileTransfer.getInstance();
if (ft.isSupportedType(event.currentDataType)) {
fileList = (String[]) event.data;
}
if (fileList != null && fileList.length > 0) {
String fileString = fileList[0];
documentSink.setText(fileString);
}
}
});
}
private void initDocumentSourceTextField() {
documentSource = new Text(this, SWT.SINGLE | SWT.BORDER);
FormData fdata1 = new FormData();
fdata1.width = 200;
fdata1.left = new FormAttachment(0, 1000, 5);
fdata1.top = new FormAttachment(0, 1000, 5);
fdata1.right = new FormAttachment(1000, 1000, -5);
documentSource.setLayoutData(fdata1);
documentSource.setToolTipText("Document source folder...");
documentSource.setMessage("Document source folder...");
DropTarget dt = new DropTarget(documentSource, DND.DROP_DEFAULT | DND.DROP_MOVE);
dt.setTransfer(new Transfer[] { FileTransfer.getInstance() });
dt.addDropListener(new DropTargetAdapter() {
@Override
public void drop(DropTargetEvent event) {
String fileList[] = null;
FileTransfer ft = FileTransfer.getInstance();
if (ft.isSupportedType(event.currentDataType)) {
fileList = (String[]) event.data;
}
if (fileList != null && fileList.length > 0) {
String fileString = fileList[0];
documentSource.setText(fileString);
}
}
});
}
private void changeType(Shell shell, Composite composite, Object node) {
AnnotationCheckComposite annotCheckCompo = null;
if (!(composite instanceof AnnotationCheckComposite)) {
return;
}
annotCheckCompo = (AnnotationCheckComposite) composite;
shell.setText("Change annotation type");
TypeSystemDescription tsd = annotCheckCompo.getTypeSystemDescription();
SelectTypesDialogCheck dialog = new SelectTypesDialogCheck(shell, tsd, null, false, SWT.SINGLE,
false);
String newTypeName = null;
if (dialog.open() == Window.OK) {
newTypeName = dialog.getChoosenType();
}
if (newTypeName != null) {
AnnotationCheckTreeNode annotCheckTreeNode = (AnnotationCheckTreeNode) node;
CheckAnnotation checkAnnot = (CheckAnnotation) annotCheckTreeNode.getElement();
checkAnnot.setTypeName(newTypeName);
String[] split = newTypeName.split("\\.");
String shortTypeName = split[split.length - 1];
checkAnnot.setShortType(shortTypeName);
treeView.refresh();
return;
}
}
private void changeFeature(Shell shell, Object node) {
FeatureCheckTreeNode featTreeNode = (FeatureCheckTreeNode) node;
shell.setText("Change value of feature");
Type range = featTreeNode.getFeature().getRange();
IInputValidator validator = new ChangeFeatureValidator(range);
InputDialog dialog = new InputDialog(getShell(), "Define new feature value",
"New feature value:", "", validator);
if (dialog.open() == Window.OK) {
featTreeNode.setValue(dialog.getValue());
treeView.refresh();
return;
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.part.Page#dispose()
*/
@Override
public void dispose() {
super.dispose();
viewPart.getSite().getPage().removeSelectionListener(this);
Collection<Image> values = images.values();
for (Image image : values) {
image.dispose();
}
}
public Image getImage(String name) {
if (images == null) {
initImages();
}
return images.get(name);
}
private void initImages() {
images = new HashMap<String, Image>();
ImageDescriptor desc;
Image image;
String name;
desc = RutaAddonsPlugin.getImageDescriptor("/icons/accept.png");
image = desc.createImage();
name = "accept";
images.put(name, image);
desc = RutaAddonsPlugin.getImageDescriptor("/icons/delete.png");
image = desc.createImage();
name = "delete";
images.put(name, image);
desc = RutaAddonsPlugin.getImageDescriptor("/icons/help.png");
image = desc.createImage();
name = "help";
images.put(name, image);
desc = RutaAddonsPlugin.getImageDescriptor("/icons/bullet_blue.png");
image = desc.createImage();
name = "feature";
images.put(name, image);
desc = RutaAddonsPlugin.getImageDescriptor("/icons/folder_page.png");
image = desc.createImage();
name = "folder";
images.put(name, image);
}
@Override
public void selectionChanged(IWorkbenchPart part, ISelection selection) {
if (part instanceof AnnotationCheckView) {
if (selection instanceof TreeSelection) {
TreeSelection ts = (TreeSelection) selection;
if (ts.getFirstElement() instanceof FeatureCheckTreeNode) {
return;
}
if (ts.getFirstElement() instanceof AnnotationCheckTreeNode) {
AnnotationCheckTreeNode firstElement = (AnnotationCheckTreeNode) ts.getFirstElement();
CheckElement element = firstElement.getElement();
int begin = 0;
int end = 0;
CheckDocument newDoc = null;
if (element instanceof CheckAnnotation) {
begin = ((CheckAnnotation) element).getBegin();
end = ((CheckAnnotation) element).getEnd();
newDoc = ((CheckDocument) firstElement.getParent().getElement());
} else if (element instanceof CheckDocument) {
newDoc = ((CheckDocument) element);
} else {
return;
}
if (casEditor != null && casEditor.getDocumentProvider() != null
&& casEditor.getDocument() != null) {
IFile file = ((FileEditorInput) casEditor.getEditorInput()).getFile();
if (!newDoc.source.equals(file.getLocation().toOSString())) {
casEditor.getDocument().removeChangeListener(annotationListener);
casEditor = CheckAnnotationUtils.openInCasEditor(new File(newDoc.source), begin, end);
casEditor.getDocument().addChangeListener(annotationListener);
} else {
casEditor.selectAndReveal(begin, end - begin);
}
} else {
casEditor = CheckAnnotationUtils.openInCasEditor(new File(newDoc.source), begin, end);
casEditor.getDocument().addChangeListener(annotationListener);
}
setAnnotationMode(annotationMode);
Iterator<Type> typeIterator = casEditor.getDocument().getCAS().getTypeSystem()
.getTypeIterator();
while (typeIterator.hasNext()) {
Type type = typeIterator.next();
boolean contains = typesToCheck.containsKey(type.getName());
casEditor.setShownAnnotationType(type, contains);
}
currentDocument = newDoc;
treeView.getControl().setFocus();
}
}
}
}
@Override
public void selectionChanged(SelectionChangedEvent arg0) {
}
public void restoreState(IMemento memento) {
if (memento == null)
return;
IMemento dir = memento.getChild("documentSource");
if (dir != null) {
String id = dir.getID();
documentSource.setText(id);
}
IMemento dir2 = memento.getChild("documentSink");
if (dir2 != null) {
String id = dir2.getID();
documentSink.setText(id);
}
IMemento tsName = memento.getChild("typeSystem");
if (tsName != null) {
String id = tsName.getID();
pathToTypeSystem.setText(id);
}
IMemento selectedTypes = memento.getChild("typesToCheck");
if (selectedTypes != null) {
typesToCheck = new HashMap<String, Set<String>>();
for (IMemento mementoTypesToCheck : selectedTypes.getChildren(selectedTypes.getID())) {
String typeName = mementoTypesToCheck.getID();
Set<String> features = new HashSet<String>();
for (IMemento mementoFeature : mementoTypesToCheck.getChildren("feature")) {
features.add(mementoFeature.getID());
}
typesToCheck.put(typeName, features);
}
}
IMemento uncheckedTypes = memento.getChild("typesToTransferUnchecked");
if (uncheckedTypes != null) {
typesToTransferUnchecked = new HashSet<String>();
for (IMemento mementoUnchecked : uncheckedTypes.getChildren(uncheckedTypes.getID())) {
String typeName = mementoUnchecked.getID();
typesToTransferUnchecked.add(typeName);
}
}
}
public void saveState(IMemento memento) {
memento.createChild("documentSource", documentSource.getText());
memento.createChild("documentSink", documentSink.getText());
memento.createChild("typeSystem", pathToTypeSystem.getText());
IMemento selectedTypesMemento = memento.createChild("typesToCheck", "type");
for (Entry<String, Set<String>> checkedTypeEntry : typesToCheck.entrySet()) {
IMemento selectedTypeMemento = selectedTypesMemento.createChild("type",
checkedTypeEntry.getKey());
for (String feature : checkedTypeEntry.getValue()) {
selectedTypeMemento.createChild("feature", feature);
}
}
IMemento uncheckTypesMemento = memento.createChild("typesToTransferUnchecked", "unchecked");
for (String uncheckedTypeName : typesToTransferUnchecked) {
uncheckTypesMemento.createChild("unchecked", uncheckedTypeName);
}
}
public TreeViewer getTreeViewer() {
return treeView;
}
public String getDocumentSource() {
return documentSource.getText();
}
public String getDocumentSink() {
return documentSink.getText();
}
public String getPathToTypeSystem() {
return pathToTypeSystem.getText();
}
public Map<String, Set<String>> getCheckedTypes() {
return typesToCheck;
}
public void setTypesToCheck(Map<String, Set<String>> typesToCheck) {
this.typesToCheck = typesToCheck;
}
public void reject(boolean doMove) {
TreeSelection selection = (TreeSelection) treeView.getSelection();
AnnotationCheckTreeNode firstElement = (AnnotationCheckTreeNode) selection.getFirstElement();
if (firstElement == null) {
return;
}
firstElement.getElement().checked = true;
firstElement.getElement().keep = false;
if (doMove) {
moveToNext();
}
treeView.refresh();
}
public void accept() {
TreeSelection selection = (TreeSelection) treeView.getSelection();
AnnotationCheckTreeNode firstElement = (AnnotationCheckTreeNode) selection.getFirstElement();
if (firstElement == null) {
return;
}
firstElement.getElement().checked = true;
firstElement.getElement().keep = true;
List<AnnotationCheckTreeNode> siblings = Arrays.asList(firstElement.getParent().getChildren());
int indexOfFirstElement = siblings.indexOf(firstElement);
CheckAnnotation firstElementAnnotation = (CheckAnnotation) firstElement.getElement();
moveToNext();
for (int i = indexOfFirstElement + 1; i < siblings.size(); i++) {
CheckElement nextSiblingCE = siblings.get(i).getElement();
if (nextSiblingCE instanceof CheckAnnotation) {
CheckAnnotation nextSibling = (CheckAnnotation) nextSiblingCE;
if (nextSibling.getBegin() == firstElementAnnotation.getBegin()
&& nextSibling.getEnd() == firstElementAnnotation.getEnd()) {
reject(true);
} else {
break;
}
if (i == siblings.size() - 1) {
IAnnotationCheckTreeNode parent = siblings.get(0).getParent();
parent.getElement().checked = true;
parent.getElement().keep = true;
}
}
}
treeView.refresh();
}
public void moveToNext() {
TreeSelection selection = (TreeSelection) treeView.getSelection();
IAnnotationCheckTreeNode parent = null;
AnnotationCheckTreeNode firstElement = null;
if (selection.getFirstElement() instanceof FeatureCheckTreeNode) {
return;
}
firstElement = (AnnotationCheckTreeNode) selection.getFirstElement();
parent = firstElement.getParent();
IAnnotationCheckTreeNode[] children = parent.getChildren();
List<IAnnotationCheckTreeNode> list = Arrays.asList(children);
int indexOf = list.indexOf(firstElement);
IAnnotationCheckTreeNode brother = null;
IAnnotationCheckTreeNode uncle = parent;
if (list == null || list.isEmpty()) {
} else if (indexOf == -1) {
brother = list.get(0);
} else if (firstElement.getElement() instanceof CheckDocument && indexOf < list.size() - 1) {
uncle = list.get(indexOf + 1);
if (uncle.getChildren().length > 0) {
brother = uncle.getChildren()[0];
}
} else if (indexOf < list.size() - 1) {
brother = list.get(indexOf + 1);
} else if (firstElement.getElement() instanceof CheckAnnotation) {
brother = null;
IAnnotationCheckTreeNode[] children2 = parent.getParent().getChildren();
List<IAnnotationCheckTreeNode> list2 = Arrays.asList(children2);
int indexOf2 = list2.indexOf(parent);
if (list2 == null || list2.isEmpty()) {
} else if (indexOf2 == -1) {
uncle = list2.get(0);
} else if (indexOf2 < list2.size() - 1) {
uncle = list2.get(indexOf2 + 1);
if (uncle.getChildren().length != 0) {
brother = uncle.getChildren()[0];
}
}
}
TreePath treePath = null;
if (brother == null) {
treePath = new TreePath(new Object[] { treeView.getInput(), uncle });
} else {
treePath = new TreePath(new Object[] { treeView.getInput(), uncle, brother });
}
final TreeSelection newSelection = new TreeSelection(treePath);
treeView.setSelection(newSelection, true);
treeView.expandToLevel(((AnnotationCheckTreeNode) newSelection.getFirstElement()).getParent(),
TreeViewer.ALL_LEVELS);
if (firstElement.getElement() instanceof CheckAnnotation) {
boolean allChecked = true;
boolean oneKeep = false;
for (IAnnotationCheckTreeNode each : list) {
CheckElement element = each.getElement();
allChecked &= element.checked;
oneKeep |= element.keep;
}
parent.getElement().checked = allChecked;
parent.getElement().keep = oneKeep;
}
}
public void save() {
AnnotationCheckTreeNode root = (AnnotationCheckTreeNode) treeView.getInput();
AnnotationCheckTreeNode[] children = root.getChildren();
List<CheckDocument> docs = new ArrayList<CheckDocument>(oldDocs);
TypeSystemDescription tsd = getTypeSystemDescription();
CAS casSource = null;
CAS cas = null;
try {
cas = CasCreationUtils.createCas(tsd, null, new FsIndexDescription[0]);
casSource = CasCreationUtils.createCas(tsd, null, new FsIndexDescription[0]);
} catch (ResourceInitializationException e) {
RutaAddonsPlugin.error(e);
}
for (AnnotationCheckTreeNode each : children) {
CheckDocument cd = (CheckDocument) each.getElement();
if (cd.checked && cd.keep) {
cas.reset();
File oldFile = new File(cd.source);
File goldFile = new File(documentSink.getText(), oldFile.getName());
try {
if (goldFile.exists()) {
XmiCasDeserializer.deserialize(new FileInputStream(goldFile), cas, false);
} else {
XmiCasDeserializer.deserialize(new FileInputStream(oldFile), cas, true);
}
} catch (FileNotFoundException e) {
RutaAddonsPlugin.error(e);
} catch (SAXException e) {
RutaAddonsPlugin.error(e);
} catch (IOException e) {
RutaAddonsPlugin.error(e);
}
String documentText = cas.getDocumentText();
cas.reset();
cas.setDocumentText(documentText);
try {
XmiCasDeserializer.deserialize(new FileInputStream(oldFile), casSource, true);
} catch (FileNotFoundException e) {
RutaAddonsPlugin.error(e);
} catch (SAXException e) {
RutaAddonsPlugin.error(e);
} catch (IOException e) {
RutaAddonsPlugin.error(e);
}
for (String uncheckedTypeName : typesToTransferUnchecked) {
Type type = cas.getTypeSystem().getType(uncheckedTypeName);
if (type != null) {
for (AnnotationFS annot : casSource.getAnnotationIndex(type)) {
cas.addFsToIndexes(cas.createAnnotation(type, annot.getBegin(), annot.getEnd()));
}
}
}
AnnotationCheckTreeNode[] annotationNodes = each.getChildren();
for (AnnotationCheckTreeNode eachAN : annotationNodes) {
CheckAnnotation ca = (CheckAnnotation) eachAN.getElement();
if (ca.checked && ca.keep) {
TypeSystem ts = casEditor.getDocument().getCAS().getTypeSystem();
Type type = ts.getType(ca.getTypeName());
if (type != null) {
AnnotationFS annotFS = ca.toAnnotationFS(cas, type);
if (eachAN.hasChildren()) {
FeatureCheckTreeNode[] featureNodes = (FeatureCheckTreeNode[]) eachAN.getChildren();
for (FeatureCheckTreeNode featureNode : featureNodes) {
Feature feature = featureNode.getFeature();
try {
annotFS.setFeatureValueFromString(feature, featureNode.getValue());
} catch (Exception e) {
continue;
}
}
}
cas.addFsToIndexes(annotFS);
}
}
}
try {
CheckAnnotationUtils.writeXmi(cas, goldFile);
} catch (Exception e) {
RutaAddonsPlugin.error(e);
}
cd.checkedTypes.addAll(typesToCheck.keySet());
if (!docs.contains(cd)) {
docs.add(cd);
}
}
File dataFile = new File(documentSink.getText(), "data.xml");
try {
XMLUtils.write(docs, dataFile);
} catch (IOException e) {
RutaAddonsPlugin.error(e);
}
}
}
public void setAnnotationMode(String typeString) {
this.annotationMode = typeString;
if (casEditor != null && casEditor.getDocument() != null && typeString != null) {
Type type = casEditor.getDocument().getCAS().getTypeSystem().getType(typeString);
casEditor.setAnnotationMode(type);
}
}
public void addAnnotations(Collection<AnnotationFS> annotations) {
AnnotationCheckRootNode root = (AnnotationCheckRootNode) treeView.getInput();
AnnotationCheckTreeNode[] children = root.getChildren();
for (AnnotationCheckTreeNode docNode : children) {
if (docNode.getElement().equals(currentDocument)) {
List<AnnotationCheckTreeNode> annotationList = new ArrayList<AnnotationCheckTreeNode>(
Arrays.asList(docNode.getChildren()));
for (AnnotationFS eachAnnotation : annotations) {
CheckElement ac = new CheckAnnotation(eachAnnotation);
ac.checked = true;
ac.keep = true;
AnnotationCheckTreeNode anode = new AnnotationCheckTreeNode(docNode, ac);
annotationList.add(anode);
}
Collections.sort(annotationList, comparator);
docNode.setChildren(annotationList);
treeView.refresh(docNode);
break;
}
}
}
public void removeAnnotations(Collection<AnnotationFS> annotations) {
AnnotationCheckRootNode root = (AnnotationCheckRootNode) treeView.getInput();
AnnotationCheckTreeNode[] children = root.getChildren();
for (AnnotationCheckTreeNode docNode : children) {
if (docNode.getElement().equals(currentDocument)) {
AnnotationCheckTreeNode[] achildren = docNode.getChildren();
for (AnnotationCheckTreeNode anode : achildren) {
CheckAnnotation checkAnnotation = (CheckAnnotation) anode.getElement();
for (AnnotationFS eachAnnotation : annotations) {
if (eachAnnotation.getBegin() == checkAnnotation.getBegin()
&& eachAnnotation.getEnd() == checkAnnotation.getBegin()
&& eachAnnotation.getType().getName().equals(checkAnnotation.getTypeName())) {
checkAnnotation.checked = true;
checkAnnotation.keep = false;
}
}
}
treeView.refresh(docNode);
break;
}
}
}
public void updateAnnotations(Collection<AnnotationFS> annotations) {
}
public void setOldDocs(List<CheckDocument> docs) {
this.oldDocs = docs;
}
public TypeSystemDescription getTypeSystemDescription() {
refreshTypeSystem();
return tsd;
}
public void refreshTypeSystem() {
try {
String typeSystem = getPathToTypeSystem();
TypeSystemDescription tsd = UIMAFramework.getXMLParser().parseTypeSystemDescription(
new XMLInputSource(new File(typeSystem)));
tsd.resolveImports();
this.tsd = tsd;
} catch (InvalidXMLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public Map<String, Set<String>> getUncheckedTypes() {
Map<String, Set<String>> map = new HashMap<String, Set<String>>();
for (String entry : typesToTransferUnchecked) {
map.put(entry, null);
}
return map;
}
public void setUncheckedTypes(Set<String> typesToTransferUnchecked) {
this.typesToTransferUnchecked = typesToTransferUnchecked;
}
}