Laboratoire ICAR » Plateforme TXM

Export-Package: org.txm.annotation.rcp.commands,

 org.txm.annotation.rcp.concordance,

package org.txm.annotation.rcp.concordance;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import org.txm.annotation.core.Annotation;

import org.txm.annotation.core.AnnotationManager;

import org.txm.annotation.core.KRAnnotationEngine;

import org.txm.annotation.core.repository.AnnotationType;

import org.txm.annotation.core.repository.TypedValue;

import org.txm.concordance.core.functions.Concordance;

import org.txm.concordance.core.functions.Line;

import org.txm.concordance.core.messages.ConcordanceMessages;

import org.txm.searchengine.cqp.clientExceptions.CqiClientException;

import org.txm.searchengine.cqp.corpus.query.Match;

import org.txm.searchengine.cqp.serverException.CqiServerError;

import org.txm.utils.logger.Log;

public class ConcordanceAnnotations {

	Concordance concordance;

	private AnnotationType viewAnnotation;

	public ConcordanceAnnotations(Concordance concordance) {

	}

	private boolean overlapAnnotation;

	private ArrayList<AnnotationLine> lines;

	private List<Line> concordanceLines;

	public void setAnnotationOverlap(boolean overlap) {

		overlapAnnotation = overlap;

	}

	public boolean getAnnotationOverlap() {

		return overlapAnnotation;

	}

	public List<AnnotationLine> getLines(int from, int to) throws CqiClientException, IOException, CqiServerError {

		concordanceLines = concordance.getLines(from, to);

		ArrayList<Match> matches = new ArrayList<Match>();

		for (Line line : concordanceLines) matches.add(line.getMatch());

		List<Annotation> ann = getAnnotationForMatches(matches, overlapAnnotation);

		lines = new ArrayList<AnnotationLine>();

		for (Annotation a : ann) {

			AnnotationLine aline = new AnnotationLine(a, getAnnotationTypedValue(a));

			lines.add(aline);

		}

		return lines; // TODO find a way to add 

	}

	private String findAnnotationForLine(Match match, List<Annotation> annots, boolean overlap) {

		String annotationValue = "";

		if (annots!=null) {

			if (!annots.isEmpty()) {

				for (Annotation annot : annots) {

					if (overlap) {

						if ((annot.getStart()<=match.getStart() && annot.getEnd()>=match.getEnd()) || (annot.getStart()>match.getStart() && annot.getEnd()<match.getEnd())

								) {

							annotationValue = annot.getValue(); 

							// use the first Annotation found, the one stored in the temporary HSQL database

							//should be modified to display a list of annotation values corresponding to the match positions (or wrapped if overlap is admitted)

						}

					} else {

						if (annot.getStart()==match.getStart() && annot.getEnd()==match.getEnd()) {

							annotationValue = annot.getValue(); 

							// use the first Annotation found, the one stored in the temporary HSQL database

						}

					}

				}

			}

		}

		return annotationValue;

	}

	public TypedValue getAnnotationTypedValue(Annotation annotation) { 

		TypedValue annotationValue = null;

		if (annotation!=null) {

			annotationValue = viewAnnotation.getTypedValue(annotation.getValue());

			if (annotationValue == null) { // the annotation is not stored in the KR type -> the annotation is surely built with the CQPAnnotationManager

				//System.out.println("WARNING: no annotation value found for value id="+annotation.getValue()+" - will be created.");

				annotationValue = new TypedValue(annotation.getValue(), annotation.getValue(), annotation.getType());

			}

		}

		return annotationValue;

	}

	public AnnotationType getViewAnnotation(AnnotationType type) {

		return viewAnnotation;

	}

	private List<Annotation> prepareAnnotationsList(List<Match> matches, List<Annotation> annotations, boolean overlap){

		List<Annotation> annotsList = new ArrayList<Annotation>();

		int iMatch = 0;

		int iAnnotation = 0;

		int nMatch = matches.size();

		int nAnnotations = annotations.size();

		while (iMatch < nMatch && iAnnotation < nAnnotations) {

			if (overlap) {

				if (matches.get(iMatch).getEnd() < annotations.get(iAnnotation).getStart()) {

					iMatch++;

					annotsList.add(null); // nothing for this match

				} else if (annotations.get(iAnnotation).getEnd() < matches.get(iMatch).getStart()) {

					iAnnotation++;

				} else {

					annotsList.add(annotations.get(iAnnotation));

					iMatch++;

				}

			} else {

				if (matches.get(iMatch).getEnd() < annotations.get(iAnnotation).getStart()) {

					iMatch++;

					annotsList.add(null); // nothing for this match

				} else if (annotations.get(iAnnotation).getEnd() < matches.get(iMatch).getStart()) {

					iAnnotation++;

				} else if (annotations.get(iAnnotation).getStart() == matches.get(iMatch).getStart() && 

						annotations.get(iAnnotation).getEnd() == matches.get(iMatch).getEnd()) {

					annotsList.add(annotations.get(iAnnotation));

					iMatch++;

					iAnnotation++;

				} else {

					iAnnotation++;

				}

			}

		}

		while (annotsList.size() < matches.size() ) annotsList.add(null); // fill matches that were not process due to no more annotations

		return annotsList;

	}

	private HashMap<Match, Annotation> prepareAnnotationsMap(List<Match> matches, List<Annotation> annots, boolean overlap){

		HashMap<Match, Annotation> annotsList = new HashMap<Match, Annotation>();

		for (Match m : matches) {

			boolean hasAnnotations = false;

			if (annots!=null) {

				if (!annots.isEmpty()) {

					for (Annotation annot : annots) {

						if (overlap){

							if ((annot.getStart() <= m.getStart() && m.getStart() <= annot.getEnd() && m.getEnd() >= annot.getEnd()) || 

									(annot.getStart() <= m.getEnd() && m.getEnd() <= annot.getEnd() && m.getStart() <= annot.getStart()) 

									|| !(annot.getEnd() < m.getStart() || annot.getStart() > m.getEnd())){

								annotsList.put(m, annot);

								hasAnnotations = true;

							}

						} else {

							if (annot.getStart()==m.getStart() && annot.getEnd()==m.getEnd()) {

								annotsList.put(m, annot); 

								hasAnnotations = true;

							}

						}

					}

				}

			}

			if (!hasAnnotations) {

				annotsList.put(m, null);

			}

		}

		return annotsList;

	}

	public List<Annotation> getAnnotationForMatches(List<Match> subsetMatch, boolean overlapAnnotation) {

		AnnotationManager am = KRAnnotationEngine.getAnnotationManager(concordance.getCorpus());

		//List<Annotation> allAnnotations = null;

		List<Annotation> annotationsPerMatch = null;;

		if (viewAnnotation != null && am != null) {

			try {

				annotationsPerMatch = am.getAnnotationsForMatches(viewAnnotation, subsetMatch, overlapAnnotation);

				//System.out.println("annotationsPerMatch: "+annotationsPerMatch);

			} catch (Exception e) {

				System.out.println("Error while reading annotation "+viewAnnotation+" and with "+subsetMatch.size()+" matches");

				Log.printStackTrace(e);

			}

		}

		return annotationsPerMatch;

	}

	public void setViewAnnotation(AnnotationType type) {

		viewAnnotation = type;

		concordance.resetLines();

	}

	/**

	 * 

	 * @param i the relative position of the AnnotationLine in the lines list

	 * 

	 * @return the AnnotationLine pointed by 'i'. May return null if i is wrong.

	 */

	public AnnotationLine getAnnotationLine(Line line) {

		int i = concordanceLines.indexOf(line);

		if (i < 0) return null;

		return getAnnotationLine(i);

	}

	/**

	 * 

	 * @param i the relative position of the AnnotationLine in the lines list

	 * 

	 * @return the AnnotationLine pointed by 'i'. May return null if i is wrong.

	 */

	public AnnotationLine getAnnotationLine(int i) {

		if (lines.size() < i) return null;

		if (i < 0) return null;

		return lines.get(i);

	}

}

package org.txm.annotation.rcp.concordance;

import org.txm.annotation.core.Annotation;

import org.txm.annotation.core.repository.TypedValue;

public class AnnotationLine {

	private TypedValue annotationValue;

	private Annotation annotation;

	public AnnotationLine(Annotation annotation, TypedValue annotationValue) {

		this.annotation = annotation;

		this.annotationValue = annotationValue; 

	}

	public Annotation getAnnotation() {

		return annotation;

	}

	public TypedValue getAnnotationValue() {

		return annotationValue;

	}

}

package org.txm.annotation.rcp.concordance;

import org.txm.annotation.core.Annotation;

import org.txm.concordance.core.functions.LineDecorator;

public class AnnotationLineDecorator extends LineDecorator {

	ConcordanceAnnotations annotations;

	public AnnotationLineDecorator(ConcordanceAnnotations annotations) {

		this.annotations = annotations;

	}

	/**

	 * Add "<" or ">" depending of the current position of the match and the annotation start end positions

	 */

	@Override

	public String decorate(int i, int currentPos, String str) {

		Annotation annotation = annotations.getAnnotationLine(i).getAnnotation();

		if (annotation != null) {

			if (currentPos == annotation.getStart()) {

				return "< "+str;

			} else if (currentPos == annotation.getEnd()) {

				return str+" >";

			}

		}

		return str;

	}

}

package org.txm.annotation.rcp.concordance;

import java.io.File;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Vector;

import java.util.logging.Level;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.jface.dialogs.InputDialog;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.jface.viewers.ColumnLabelProvider;

import org.eclipse.jface.viewers.ComboViewer;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TableViewerColumn;

import org.eclipse.jface.viewers.ViewerCell;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.events.ControlListener;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.events.KeyListener;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Combo;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.TableColumn;

import org.eclipse.swt.widgets.Text;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.dialogs.ListDialog;

import org.txm.concordance.core.functions.Concordance;

import org.txm.concordance.core.functions.Line;

import org.txm.concordance.rcp.editors.ConcordanceEditor;

import org.txm.concordance.rcp.editors.ConcordanceEditor.ConcordanceColumnSizeControlListener;

import org.txm.concordance.rcp.editors.ConcordanceEditorExtension;

import org.txm.concordance.rcp.messages.Messages;

import org.txm.core.preferences.TXMPreferences;

import org.txm.rcp.IImageKeys;

import org.txm.rcp.RCPMessages;

import org.txm.rcp.commands.OpenBrowser;

import org.txm.rcp.preferences.RCPPreferences;

import org.txm.rcp.swt.dialog.ConfirmDialog;

import org.txm.rcp.swt.provider.SimpleLabelProvider;

import org.txm.rcp.utils.JobHandler;

import org.txm.rcp.views.corpora.CorporaView;

import org.txm.searchengine.cqp.clientExceptions.CqiClientException;

import org.txm.searchengine.cqp.corpus.Corpus;

import org.txm.searchengine.cqp.corpus.query.Match;

import org.txm.utils.AsciiUtils;

import org.txm.utils.logger.Log;

import org.txm.annotation.core.Annotation;

import org.txm.annotation.core.AnnotationManager;

import org.txm.annotation.core.KRAnnotationEngine;

import org.txm.annotation.core.preferences.AnnotationPreferences;

import org.txm.annotation.core.repository.AnnotationType;

import org.txm.annotation.core.repository.KnowledgeRepository;

import org.txm.annotation.core.repository.KnowledgeRepositoryManager;

import org.txm.annotation.core.repository.LocalKnowledgeRepository;

import org.txm.annotation.core.repository.SQLKnowledgeRepository;

import org.txm.annotation.core.repository.TypedValue;

import org.txm.annotation.rcp.commands.InitializeKnowledgeRepository;

import org.txm.annotation.rcp.commands.SaveAnnotations;

import org.txm.annotation.rcp.commands.krview.OpenKRView;

import org.txm.annotation.rcp.views.knowledgerepositories.KRView;

public class ConcordanceAnnotationExtension extends ConcordanceEditorExtension {

	/**

	 * the limit number of annotation when a confirm dialog box is shown

	 */

	protected static final int NALERTAFFECTANNOTATIONS = 100;

	/** The annotation service */

	protected AnnotationManager  annotManager;

	//boolean annotation_expert_mode = TxmPreferences.getBoolean(AnnotationPreferencePage.MODE, false);

	/** The annotation area. */

	protected Composite annotationArea;

	protected Point annotationSize;

	/** The annot btn. */

	protected Button annotationButton;

	private Button addAnnotationTypeLink;

	protected Text annotationValuesText;

	protected ComboViewer annotationTypesCombo;

	protected List<TypedValue> typeValuesList;

	protected Point annotSize;

	protected TableColumn annotationColumn;

	protected Combo addRemoveCombo;

	protected Combo affectCombo;

	protected Button affectAnnotationButton;

	protected Button infosAnnotTypeSelectedLink;

	protected HashMap<AnnotationType, ArrayList<TypedValue>> history = new HashMap<AnnotationType, ArrayList<TypedValue>>();

	protected KnowledgeRepository currentKnowledgeRepository = null;

	protected Vector<AnnotationType> typesList = new Vector<AnnotationType>(); 

	protected Button addTypedValueLink;

	protected Label withLabel;

	protected AnnotationType tagAnnotationType; // the tag annotation type if annotation mode is simple

	protected Label equalLabel;

	protected Boolean advanced_annotation_mode = false;

	protected TypedValue value_to_add;

	protected Concordance concordance;

	private Corpus corpus;

	private ConcordanceAnnotations annotations;

	public ConcordanceAnnotationExtension() {

	}

	@Override

	public String getName() {

		return "Annotation";

	}

	@Override

	public boolean installWidgets() throws Exception {

		final Composite controlArea = editor.getNavigationArea();

		final Composite navigationArea = editor.getNavigationArea();

		TableViewer viewer = editor.getLineTableViewer();

		// CONTROLS

		if (KRAnnotationEngine.getKnowledgeRepositoryNames(corpus).size() > 0) { // shown only if corpus has a registered KR

			annotationButton = new Button(navigationArea, SWT.PUSH);

			annotationButton.setToolTipText(Messages.ConcordancesEditor_75);

			annotationButton.setImage(IImageKeys.getImage(IImageKeys.PENCIL));

			annotationButton.addSelectionListener(new SelectionListener() {

				@Override

				public void widgetSelected(SelectionEvent e) {

					if (annotationArea != null) {

						AnnotationManager am = KRAnnotationEngine.getAnnotationManager(corpus);

						if (am != null && am.hasChanges()) {

							// && MessageDialog.openConfirm(e.display.getActiveShell(), "Confirm annotation save", "Saving annotation will close this editor. Are you sure you want to save annotations right now ?")

							JobHandler saveJob = SaveAnnotations.save(corpus.getMainCorpus());

							if (saveJob.getResult() == Status.CANCEL_STATUS) {

								// update editor corpus

								System.out.println("Fail to save annotations of the corpus."); //$NON-NLS-1$

							}

						}

					} else {

						if (annotationArea == null) composeAnnotationArea(controlArea);

						if (annotationArea == null) return;

						annotationColumn.pack();

						annotationButton.setToolTipText(Messages.ConcordancesEditor_76);

						annotationButton.setImage(IImageKeys.getImage(IImageKeys.PENCIL_SAVE));

						annotSize = annotationArea.getSize();

						Point size = controlArea.getSize();

						controlArea.setSize(size.x, size.y + annotSize.y);

						GridData data = (GridData) annotationArea.getLayoutData();

						data.heightHint = annotSize.y;

						data.minimumHeight = annotSize.y;

						annotationArea.setSize(annotSize);

						controlArea.layout(true);

						controlArea.getParent().layout();

						if (concordance != null) {

							AnnotationType type = getSelectedAnnotationType();

							if (type != null) {

								annotations.setViewAnnotation(type);

								annotations.setAnnotationOverlap(true);

								editor.fillDisplayArea(editor.getTopLine(), editor.getBottomLine()+1);

							}

						}

						CorporaView.refreshObject(corpus);

					}

				}

				@Override

				public void widgetDefaultSelected(SelectionEvent e) {	}

			});

		}

		// RESULT

		int position = 3;

		TableViewerColumn annotationColumnViewer = new TableViewerColumn(viewer, SWT.CENTER, position);

		annotationColumn = annotationColumnViewer.getColumn();

		annotationColumn.setText(Messages.ConcordancesEditor_15);

		annotationColumn.setToolTipText(Messages.ConcordancesEditor_17);

		annotationColumn.setAlignment(SWT.CENTER);

		annotationColumn.addControlListener(new ConcordanceColumnSizeControlListener(annotationColumn));

		annotationColumnViewer.setLabelProvider(new ColumnLabelProvider() {

			@Override

			public String getText(Object element) {

				Line line = (Line)element;

				AnnotationLine annotationLine = annotations.getAnnotationLine(line);

				if (annotationLine.getAnnotation()!=null) {

					String value = annotationLine.getAnnotationValue().getStandardName();

					Annotation a = annotationLine.getAnnotation();

					if (value == null) value = a.getValue();

					if (a.getStart() < line.matchGetStart() - line.getLeftContextSize()) {

						value = "… "+value;

					}

					if (a.getEnd() > line.matchGetEnd() + line.getRightContextSize()) {

						value = value+" …";

					} 

					return value;

				} else {

					return "";

				}

			}

		});

		return true;

	}

	public boolean initialiseInput(ConcordanceEditor editor) throws Exception {

		this.editor = editor;

		concordance = editor.getConcordance();

		annotations = new ConcordanceAnnotations(concordance);

		corpus = concordance.getCorpus();

		Corpus corpus = editor.getCorpus();

		this.annotManager = KRAnnotationEngine.getAnnotationManager(corpus);

		return true;

	}

	private void composeAnnotationArea(final Composite parent){ 

		advanced_annotation_mode = "advanced".equals(TXMPreferences.getString(AnnotationPreferences.ANNOTATION_MODE, RCPPreferences.PREFERENCES_NODE));

		List<KnowledgeRepository> krs = InitializeKnowledgeRepository.get(corpus.getMainCorpus());

		typesList.clear();

		Log.warning("Corpus KRs: "+krs); //$NON-NLS-1$

		for (KnowledgeRepository kr : krs) {

			if (kr == null) continue;

			currentKnowledgeRepository = kr;

			Log.warning(" KR: "+kr); //$NON-NLS-1$

			List<AnnotationType> krtypes = kr.getAllAnnotationTypes();

			Log.warning("Advanced annotation mode ? "+advanced_annotation_mode);

			if (!advanced_annotation_mode) { // creates the "span" annotation type

				boolean createTagAnnotationType = true;

				for (AnnotationType type : krtypes) {

					if (type.getName().equals("span")) { //$NON-NLS-1$

						createTagAnnotationType = false;

					}

				}

				if (createTagAnnotationType) {

					tagAnnotationType = kr.addType("span", "span");//corresponds to an "undef" type //$NON-NLS-1$ //$NON-NLS-2$

					typesList.add(tagAnnotationType);

				} else {

					tagAnnotationType = kr.getType("span"); //$NON-NLS-1$

				}

			} else {

				typesList.addAll(krtypes);

			}

			Log.warning("Available annotation types: "+typesList);

			break;

		}

		if (currentKnowledgeRepository == null) {

			System.out.println("Error: no suitable KnowledgeRepository found");

			return;

		}

		annotationArea = new Composite(parent, SWT.NONE);

		annotationArea.setLayoutData(new GridData(SWT.FILL, SWT.LEFT, false, false));

		GridLayout annotLayout = new GridLayout(12, false);

		annotLayout.verticalSpacing = 0;

		annotLayout.marginWidth = 0;

		annotLayout.marginHeight = 0;

		annotationArea.setLayout(annotLayout);

		//init values history

		for (AnnotationType type : typesList) {

			history.put(type, new ArrayList<TypedValue>());

		}

		addRemoveCombo = new Combo(annotationArea, SWT.READ_ONLY);

		String affectLabel = currentKnowledgeRepository.getString(editor.getLocale(), "ConcordancesEditor_22");

		if (affectLabel == null) affectLabel= Messages.ConcordancesEditor_22;

		String removeLabel = currentKnowledgeRepository.getString(editor.getLocale(), "ConcordancesEditor_24");

		if (removeLabel == null) removeLabel= Messages.ConcordancesEditor_24;

		String items[] = {affectLabel, removeLabel};

		addRemoveCombo.setItems(items);

		addRemoveCombo.select(0);

		addRemoveCombo.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				if (addRemoveCombo.getSelectionIndex() == 0) { // add

					annotationValuesText.setEnabled(true);

					String withLabelText = currentKnowledgeRepository.getString(editor.getLocale(), "ConcordancesEditor_83");

					if (withLabelText == null) withLabelText= Messages.ConcordancesEditor_83;

					withLabel.setText(withLabelText);

					if (equalLabel != null) equalLabel.setText("=");

				} else { // remove

					annotationValuesText.setEnabled(false);

					withLabel.setText(""); //$NON-NLS-1$

					if (equalLabel != null) equalLabel.setText("");

				}

				withLabel.redraw();

				annotationArea.layout();

				updateAnnotationWidgetStates();

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) { }

		});

		GridData gdata = new GridData(SWT.CENTER, SWT.CENTER, false, true);

		gdata.widthHint = 90;

		addRemoveCombo.setLayoutData(gdata);

		withLabel = new Label(annotationArea, SWT.NONE);

		String withLabelText = currentKnowledgeRepository.getString(editor.getLocale(), "ConcordancesEditor_83");

		if (withLabelText == null) withLabelText= Messages.ConcordancesEditor_83;

		withLabel.setText(withLabelText);

		withLabel.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false));

		if (advanced_annotation_mode) {

			equalLabel = new Label(annotationArea, SWT.NONE);

			equalLabel.setText("="); //$NON-NLS-1$

			equalLabel.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false));

		}

		//Display combo with list of Annotation Type 

		if (advanced_annotation_mode) {

			annotationTypesCombo = new ComboViewer(annotationArea, SWT.READ_ONLY);

			annotationTypesCombo.setContentProvider(new ArrayContentProvider());

			annotationTypesCombo.setLabelProvider(new SimpleLabelProvider() {

				@Override

				public String getColumnText(Object element, int columnIndex) {

					return ((AnnotationType)element).getName(); //$NON-NLS-1$

				}

				@Override

				public String getText(Object element) {

					return ((AnnotationType)element).getName(); //$NON-NLS-1$

				}

			});

			gdata = new GridData(SWT.CENTER, SWT.CENTER, false, true);

			gdata.widthHint = 200;

			annotationTypesCombo.getCombo().setLayoutData(gdata);

			annotationTypesCombo.setInput(typesList);

			if (advanced_annotation_mode.equals(RCPMessages.AnnotationPreferences_2)) {

				annotationTypesCombo.getCombo().select(0);

			}

			annotationTypesCombo.addSelectionChangedListener(new ISelectionChangedListener() {

				@Override

				public void selectionChanged(SelectionChangedEvent event) {

					AnnotationType type = getSelectedAnnotationType();

					if (type == null) return;

					if (type.getSize() != AnnotationType.ValuesSize.LARGE) {

						try {

							KnowledgeRepository kr = KnowledgeRepositoryManager.getKnowledgeRepository(type.getKnowledgeRepository());

							typeValuesList = kr.getValues(type);

						} catch (Exception e) {

							// TODO Auto-generated catch block

							e.printStackTrace();

						}

					} else { // set history values

						typeValuesList = history.get(type);

					}

					annotationColumn.setText(type.getName());

					if (concordance != null) {

						annotations.setViewAnnotation(type);

						annotations.setAnnotationOverlap(true);

						editor.fillDisplayArea(editor.getTopLine(), editor.getBottomLine()+1);

					}

					updateAnnotationWidgetStates();

				}

			});

		}

		if (advanced_annotation_mode) {

			if (currentKnowledgeRepository instanceof SQLKnowledgeRepository) {

				infosAnnotTypeSelectedLink = new Button(annotationArea, SWT.PUSH);

				infosAnnotTypeSelectedLink.setImage(IImageKeys.getImage(IImageKeys.ACTION_INFO));

				infosAnnotTypeSelectedLink.setEnabled(true);

				infosAnnotTypeSelectedLink.setLayoutData(new GridData(SWT.FILL,	SWT.CENTER, false, true));

				infosAnnotTypeSelectedLink.addSelectionListener(new SelectionListener() {

					@Override

					public void widgetSelected(SelectionEvent e) {

						AnnotationType type = getSelectedAnnotationType();

						if (type == null) return;

						String typedValueURL = type.getURL(); // may be null/empty

						if (typedValueURL != null && typedValueURL.length() > 0) {

							KnowledgeRepository kr = KnowledgeRepositoryManager.getKnowledgeRepository(type.getKnowledgeRepository());

							kr.getTypeURL(type);

						}

						if (typedValueURL != null && typedValueURL.length() > 0) {

							OpenBrowser.openfile(typedValueURL, new File(typedValueURL).getName());

						} else {

							IWorkbenchWindow window = editor.getSite().getWorkbenchWindow();

							try {

								OpenKRView.openView(window, type);

							} catch (PartInitException e1) {

								e1.printStackTrace();

							}

						}

					}

					@Override

					public void widgetDefaultSelected(SelectionEvent e) { }

				});

			}

			if (currentKnowledgeRepository instanceof LocalKnowledgeRepository) {

				addAnnotationTypeLink = new Button(annotationArea, SWT.PUSH);

				addAnnotationTypeLink.setToolTipText(Messages.ConcordancesEditor_115);

				addAnnotationTypeLink.setImage(IImageKeys.getImage(IImageKeys.ACTION_ADD));

				addAnnotationTypeLink.setEnabled(true);

				addAnnotationTypeLink.setLayoutData(new GridData(SWT.FILL,	SWT.CENTER, false, true));

				addAnnotationTypeLink.addSelectionListener(new SelectionListener() {

					@Override

					public void widgetSelected(SelectionEvent e) {

						if (currentKnowledgeRepository == null) return;

						if (!(currentKnowledgeRepository instanceof LocalKnowledgeRepository)) return;

						LocalKnowledgeRepository kr = (LocalKnowledgeRepository)currentKnowledgeRepository;

						InputDialog dialog = new InputDialog(e.widget.getDisplay().getActiveShell(), Messages.ConcordancesEditor_82, Messages.ConcordancesEditor_81, "", null); //$NON-NLS-3$

						if (dialog.open() == InputDialog.OK) {

							String name = dialog.getValue();

							if (name.trim().length() == 0) return;

							String baseid = AsciiUtils.buildId(name);

							String id = AsciiUtils.buildId(name);

							int c = 1;

							while (kr.getType(id) != null) {

								id = baseid+"_"+(c++); //$NON-NLS-1$

							}

							AnnotationType type = kr.addType(name, id, ""); //$NON-NLS-1$

							typesList.add(type);

							history.put(type, new ArrayList<TypedValue>());

							if (annotationTypesCombo != null) annotationTypesCombo.refresh();

							if (typesList.size() == 1) {

								if (annotationTypesCombo != null) annotationTypesCombo.getCombo().select(0);

								if (concordance != null) {

									annotations.setViewAnnotation(type);

									annotations.setAnnotationOverlap(true);

									editor.fillDisplayArea(editor.getTopLine(), editor.getBottomLine()+1);

								}

								annotationArea.layout(true);

							}else {

								if (typesList.size() > 1){

									if (annotationTypesCombo != null) annotationTypesCombo.getCombo().select(typesList.size()-1);

								}

							}

							KRView.refresh();

							updateAnnotationWidgetStates();

						} else {

							System.out.println("Creation aborted."); //$NON-NLS-1$

						}

					}

					@Override

					public void widgetDefaultSelected(SelectionEvent e) { }

				});

			}

		}

		if (advanced_annotation_mode) {

			Label valueLabel = new Label(annotationArea, SWT.NONE);

			String valueLabelText = currentKnowledgeRepository.getString(editor.getLocale(), "ConcordancesEditor_80");

			if (valueLabelText == null) valueLabelText= Messages.ConcordancesEditor_80;

			valueLabel.setText(valueLabelText);

			valueLabel.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false));

		}

		annotationValuesText = new Text(annotationArea, SWT.BORDER);

		annotationValuesText.setToolTipText(Messages.ConcordancesEditor_32);

		GridData gdata2 = new GridData(SWT.FILL, SWT.CENTER, false, true);

		gdata2.widthHint = 200;

		annotationValuesText.setLayoutData(gdata2);

		annotationValuesText.addKeyListener(new KeyListener() {

			@Override

			public void keyReleased(KeyEvent e) {

				if (e.keyCode == SWT.CR || e.keyCode == SWT.KEYPAD_CR) {

					affectAnnotationToSelection(editor.getLineTableViewer().getSelection());

				}

			}

			@Override

			public void keyPressed(KeyEvent e) { }

		});

		if (currentKnowledgeRepository instanceof LocalKnowledgeRepository) {

			addTypedValueLink = new Button(annotationArea, SWT.PUSH);

			addTypedValueLink.setText("..."); //$NON-NLS-1$

			if (advanced_annotation_mode.equals(RCPMessages.AnnotationPreferences_2)) {

				addTypedValueLink.setToolTipText(Messages.ConcordancesEditor_79);

			}else {

				addTypedValueLink.setToolTipText(Messages.ConcordancesEditor_77);

			}

			addTypedValueLink.setEnabled(true);

			addTypedValueLink.setLayoutData(new GridData(SWT.FILL,	SWT.CENTER, false, true));

			addTypedValueLink.addSelectionListener(new SelectionListener() {

				@Override

				public void widgetSelected(SelectionEvent e) {

					if (currentKnowledgeRepository == null) return;

					if (!(currentKnowledgeRepository instanceof LocalKnowledgeRepository)) return;

					AnnotationType type = getSelectedAnnotationType();

					if (type == null) return;

					LocalKnowledgeRepository kr = (LocalKnowledgeRepository)currentKnowledgeRepository;

					ListDialog dialog = new ListDialog(e.widget.getDisplay().getActiveShell());

					if (advanced_annotation_mode.equals(RCPMessages.AnnotationPreferences_2)) {

						String title = currentKnowledgeRepository.getString(editor.getLocale(), "ConcordancesEditor_100");

						if (title == null) title = Messages.ConcordancesEditor_100;

						dialog.setTitle(Messages.bind(title, type.getName()));//+"valeurs de "+type.getName());

					}else {

						dialog.setTitle(Messages.ConcordancesEditor_99);//+"valeurs de "+type.getName());

					}

					dialog.setContentProvider(new ArrayContentProvider());

					dialog.setLabelProvider(new SimpleLabelProvider() {

						public String getColumnText(Object element, int columnIndex) {

							if (element instanceof TypedValue)

								return ((TypedValue)element).getId();

							return element.toString();

						}

					});

					List<TypedValue> values;

					try {

						values = kr.getValues(type);

					} catch (Exception e1) {

						e1.printStackTrace();

						return;

					}

					dialog.setInput(values);

					if (dialog.open() == InputDialog.OK) {

						TypedValue value = (TypedValue) dialog.getResult()[0];

						String name = value.getId();

						if (name.trim().length() == 0) return;

						annotationValuesText.setText(name);

					} else {

					}

				}

				@Override

				public void widgetDefaultSelected(SelectionEvent e) { }

			});

		}

		affectCombo = new Combo(annotationArea, SWT.READ_ONLY);

		affectCombo.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, true));

		String items2[] = {Messages.ConcordancesEditor_35, Messages.ConcordancesEditor_42, Messages.ConcordancesEditor_49};

		affectCombo.setItems(items2);

		affectCombo.select(0);

		gdata = new GridData(SWT.CENTER, SWT.CENTER, false, true);

		gdata.widthHint = 140;

		affectCombo.setLayoutData(gdata);

		affectAnnotationButton = new Button(annotationArea, SWT.PUSH);

		affectAnnotationButton.setText(Messages.ConcordancesEditor_85);

		affectAnnotationButton.setToolTipText(Messages.ConcordancesEditor_116);

		affectAnnotationButton.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, true));

		affectAnnotationButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				int isel = affectCombo.getSelectionIndex();

				if (isel == 0) { // selected line

					affectAnnotationToSelection(editor.getLineTableViewer().getSelection());

				} else if (isel == 1) { // page

					try {

						List<Match> matches = concordance.getMatches().subList(editor.getTopLine(), editor.getBottomLine()+1);

						affectMatchesToSelection(matches);

					} catch (CqiClientException e1) {

						Log.severe(Messages.ConcordancesEditor_53+e1);

						Log.printStackTrace(e1);

						return;

					}

				} else { // all

					try {

						List<Match> matches = concordance.getMatches();

						affectMatchesToSelection(matches);

					} catch (CqiClientException e1) {

						Log.severe(Messages.ConcordancesEditor_53+e1);

						Log.printStackTrace(e1);

						return;

					}

				}

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) { }

		});

		Button cancelAnnotateButton = new Button(annotationArea, SWT.PUSH);

		cancelAnnotateButton.setText(Messages.ConcordancesEditor_101);

		cancelAnnotateButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				//@TODO Closing the annotation tool bar 

				//System.out.println("must hide");

				annotationSize = annotationArea.getSize();

				annotationArea.dispose();

				annotationArea = null;

				parent.layout(true);

				parent.layout();

				annotationButton.setToolTipText(Messages.ConcordancesEditor_75);

				annotationButton.setImage(IImageKeys.getImage(IImageKeys.PENCIL));

				annotationColumn.setWidth(0);

				annotationColumn.setResizable(false);

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) { }

		});

		updateAnnotationWidgetStates();

		parent.layout();

	}

	protected void affectAnnotationToSelection(ISelection selection) {

		final IStructuredSelection lineSelection = (IStructuredSelection) selection;

		List<Line> lines = lineSelection.toList();

		ArrayList<Match> matches = new ArrayList<Match>();

		for (Line l : lines) matches.add(l.getMatch());

		affectMatchesToSelection(matches);

	}

	protected AnnotationType getSelectedAnnotationType() {

		if (annotationTypesCombo != null) {

			IStructuredSelection isel = (IStructuredSelection)annotationTypesCombo.getSelection();

			if (isel.isEmpty()) return null;

			return (AnnotationType) isel.getFirstElement();

		} else { // simple mode

			return tagAnnotationType;

		}

	}

	protected void affectMatchesToSelection(final List<Match> matches) {

		final AnnotationType type = getSelectedAnnotationType();

		final String svalue = annotationValuesText.getText();

		final boolean doAffect = addRemoveCombo.getSelectionIndex() == 0; // add is default

		JobHandler job = new JobHandler(Messages.ConcordancesEditor_36, true) {

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				this.runInit(monitor);

				try {

					if (doAffect) {

						affectAnnotationValues(matches, type, svalue, this);

					} else {

						deleteAnnotationValues(matches, type, this);

					}

				} catch(Exception e) {

					Log.severe(Messages.ConcordancesEditor_40+e);

					Log.printStackTrace(e);

					return Status.CANCEL_STATUS;

				} catch(ThreadDeath td) {

					System.out.println("Annotation canceled by user.");

					return Status.CANCEL_STATUS;

				}

				return Status.OK_STATUS;

			}

		};

		job.startJob(true);

	}

	public void updateAnnotationWidgetStates() {

		if (annotationArea == null) return; // :)

		if (addRemoveCombo.getSelectionIndex() == 0) { // add is default

			if (getSelectedAnnotationType() != null) {

				annotationValuesText.setEnabled(true);

				affectAnnotationButton.setEnabled(true);

				affectCombo.setEnabled(true);

			} else {

				annotationValuesText.setEnabled(false);

				affectAnnotationButton.setEnabled(false);

				affectCombo.setEnabled(false);

			}

		} else {

			annotationValuesText.setEnabled(false);

			if (getSelectedAnnotationType() != null) {

				affectAnnotationButton.setEnabled(true);

				affectCombo.setEnabled(true);

			} else {

				affectAnnotationButton.setEnabled(false);

				affectCombo.setEnabled(false);

			}

		}

		if (advanced_annotation_mode.equals(RCPMessages.AnnotationPreferences_2)) {

			if (infosAnnotTypeSelectedLink != null) infosAnnotTypeSelectedLink.setEnabled(getSelectedAnnotationType() != null);

		}

		if (addTypedValueLink != null) addTypedValueLink.setEnabled(getSelectedAnnotationType() != null);

		if (concordance == null) {

			affectAnnotationButton.setEnabled(false);

			affectCombo.setEnabled(false);

		}

	}

	protected void deleteAnnotationValues(List<Match> matches, AnnotationType type, JobHandler job) {

		if (concordance == null) return;

		if (matches.size() == 0) {

			System.out.println("No lines selected. Aborting."); //$NON-NLS-1$

			return;

		}

		if (type == null) return;

		if (concordance != null) {

			try {

				if (annotManager != null && annotManager.deleteAnnotations(type, matches, job)) {

					if (Log.getLevel().intValue() < Level.WARNING.intValue()) annotManager.checkData();

					concordance.reloadLines(editor.getTopLine(), editor.getBottomLine()+1);

				} else {

					return;

				}

			} catch (Exception e1) {

				System.out.println(Messages.ConcordancesEditor_54+e1);

				Log.printStackTrace(e1);

				return;

			}

			job.syncExec(new Runnable() {

				@Override

				public void run() {

					editor.fillDisplayArea(editor.getTopLine(), editor.getBottomLine()+1);

					CorporaView.refreshObject(corpus);

				}

			});

		}

	}

	protected void affectAnnotationValues(final List<Match> matches,  final AnnotationType type, final String svalue, JobHandler job) {

		value_to_add = null; // reset

		if (concordance == null) {

			System.out.println("No concordance done. Aborting."); //$NON-NLS-1$

			return;

		}

		if (matches.size() == 0) {

			System.out.println("No line selected. Aborting."); //$NON-NLS-1$

			return;

		}

		if (type == null) return; // no type, no annotation

		job.syncExec(new Runnable() {

			@Override

			public void run() {

				if (matches.size() > NALERTAFFECTANNOTATIONS) {

					ConfirmDialog dialog = new ConfirmDialog(Display.getCurrent().getActiveShell(), 

							"confirm_annotate",  //$NON-NLS-1$

							Messages.ConcordancesEditor_86, 

							Messages.ConcordancesEditor_87+matches.size()+Messages.ConcordancesEditor_108);

					if (dialog.open() == ConfirmDialog.CANCEL) {

						System.out.println("Annotation aborted by user."); //$NON-NLS-1$

						matches.clear();

					}

				}

			}

		});

		// get value from combo text value

		Log.warning(Messages.ConcordancesEditor_57+svalue);

		final KnowledgeRepository kr = KnowledgeRepositoryManager.getKnowledgeRepository(type.getKnowledgeRepository());

		value_to_add = kr.getValue(type, svalue);

		if (value_to_add == null && kr instanceof LocalKnowledgeRepository) { // create or not the annotation is simple mode

			job.syncExec(new Runnable() {

				@Override

				public void run() {

					String title = kr.getString(editor.getLocale(), "ConcordancesEditor_110");

					String content = kr.getString(editor.getLocale(), "ConcordancesEditor_112");

					if (title == null ) title = Messages.ConcordancesEditor_110;

					if (content == null ) content = Messages.ConcordancesEditor_112;

					ConfirmDialog dialog = new ConfirmDialog(Display.getCurrent().getActiveShell(), 

							"create_value", //$NON-NLS-1$

							Messages.bind(title, svalue, type.getName()),  

							Messages.bind(content, svalue, type.getName()));

					if (dialog.open() == ConfirmDialog.CANCEL) {

						System.out.println("Annotation aborted by user."); //$NON-NLS-1$

						return;

					} else {

						value_to_add = kr.addValue(svalue, svalue, type.getId());

						KRView.refresh();

					}

				}

			});

		}

		if (value_to_add == null && kr instanceof LocalKnowledgeRepository) return; // canceled

		if (value_to_add == null) {	

			job.syncExec(new Runnable() {

				@Override

				public void run() {

					String mess = Messages.bind(Messages.ConcordancesEditor_58, svalue);

					System.out.println(mess);

					MessageDialog.openError(Display.getCurrent().getActiveShell(), "Annotation canceled", mess); //$NON-NLS-1$

				}

			});

			return;

		}

		Log.info(Messages.ConcordancesEditor_59+value_to_add+Messages.ConcordancesEditor_60+matches);

		// finally we can 'try' to create the annotations \o/

		try {

			HashMap<Match, List<Annotation>> existingAnnots = annotManager.createAnnotations(type, value_to_add, matches, job);

			// did we had problems ?

			if (existingAnnots!=null && existingAnnots.size() > 0) {

				String message = Messages.ConcordancesEditor_61+value_to_add.getStandardName()+

						Messages.ConcordancesEditor_62;

				for (Match m : existingAnnots.keySet()) {

					message += Messages.ConcordancesEditor_63+m+Messages.ConcordancesEditor_64;

					for (Annotation existingAnnot : existingAnnots.get(m)) {

						if (existingAnnot.getStart() < m.getStart()){

							message += Messages.ConcordancesEditor_65+existingAnnot.getType()+Messages.ConcordancesEditor_66+existingAnnot.getStart()+Messages.ConcordancesEditor_67+existingAnnot.getEnd()+Messages.ConcordancesEditor_68;

						} else {

							message += Messages.ConcordancesEditor_69+existingAnnot.getType()+Messages.ConcordancesEditor_70+existingAnnot.getStart()+Messages.ConcordancesEditor_71+existingAnnot.getEnd()+Messages.ConcordancesEditor_72;

						}

					}

				}

				final String final_message = message;

				job.syncExec(new Runnable() {

					@Override

					public void run() {

						MessageDialog.openInformation(editor.getSite().getShell(), Messages.ConcordancesEditor_73, final_message);

					}

				});

			}

			//				if (history != null && !history.get(type).contains(value_to_add))

			//					history.get(type).add(value_to_add);

			if (Log.getLevel().intValue() < Level.WARNING.intValue() && annotManager != null) annotManager.checkData();

			concordance.reloadLines(editor.getTopLine(), editor.getBottomLine()+1);

		} catch (Exception e1) {

			System.out.println(Messages.ConcordancesEditor_74+e1);

			Log.printStackTrace(e1);

			return;

		}

		job.syncExec(new Runnable() {

			@Override

			public void run() {

				editor.fillDisplayArea(editor.getTopLine(), editor.getBottomLine()+1);

				CorporaView.refreshObject(corpus);

			}

		});

	}

	@Override

	public boolean notifyStartOfCompute() throws Exception {

		if (annotationArea != null) {

			AnnotationType type = getSelectedAnnotationType();

			if (type != null) {

				annotations.setViewAnnotation(type);

				annotations.setAnnotationOverlap(true);

			}

		}

		return true;

	}

	@Override

	public boolean notifyEndOfCompute() throws Exception {

		updateAnnotationWidgetStates();

		// update annotation column width

		if (annotationArea != null) {

			annotationColumn.pack();

			annotationColumn.setResizable(true);

		} else { 

			annotationColumn.setWidth(0);

		}

		return true;

	}

	public boolean isAnnotationEnable() {

		return annotationArea != null;

	}

}

            name="Recode Corpus">

            name="Save annotations">

            name="Open KR View">

            name="Copy">

            name="Reload">

            name="Informations">

            name="Delete">

            name="Add">

            name="Export annotations">

           name="Annotation">

     <extension

         point="org.eclipse.ui.views">

      <view

            category="org.txm.rcp"

            class="org.txm.annotation.rcp.views.knowledgerepositories.KRView"

            id="org.txm.rcp.views.knowledgerepositories.KRView"

            name="KR"

            restorable="true">

      </view>

   </extension>

                     label="KR"

                     label="Export annotations"

        point="org.txm.concordance.rcp.editors.ConcordanceEditorExtension">

     <concextension

           class="org.txm.annotation.rcp.concordance.ConcordanceAnnotationExtension"

     </concextension>

Require-Bundle: org.txm.utils;bundle-version="1.0.0";visibility:=reexport,