Laboratoire ICAR » Plateforme TXM

import java.util.ArrayList;

import java.util.List;

			SelectionListener selectionListener, List<String> modes, List<SelectionListener> modeSelectionListeners) {

		for (int i = 0 ; i < modes.size() && i < modeSelectionListeners.size(); i++) {

			item1.setText(modes.get(i));

			item1.addSelectionListener(modeSelectionListeners.get(i));

	private SelectionListener listener;

		listener = new SelectionListener() {

				if (e != null && !e.doit) {

		};

		this.addSelectionListener(listener);

	public void select() {

		listener.widgetSelected(null);

	}

		controlsArea.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, false));

		GLComposite pageNavigationComposite = new GLComposite(controlsArea, SWT.NONE, "page buttons");

		pageNavigationComposite.getLayout().numColumns = 6;

		Button first = new Button(pageNavigationComposite, SWT.FLAT|SWT.PUSH);

		Button previous = new Button(pageNavigationComposite, SWT.FLAT|SWT.PUSH);

		page_text = new org.eclipse.swt.widgets.Text(pageNavigationComposite, SWT.BORDER);

		page_label = new Label(pageNavigationComposite, SWT.NONE);

		Button next = new Button(pageNavigationComposite, SWT.FLAT|SWT.PUSH);

		Button last = new Button(pageNavigationComposite, SWT.FLAT|SWT.PUSH);

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

		GLComposite textNavigationComposite = new GLComposite(controlsArea, SWT.NONE, "text buttons");

		textNavigationComposite.getLayout().numColumns = 6;

		Button firstText = new Button(textNavigationComposite, SWT.FLAT);

		Button previousText = new Button(textNavigationComposite, SWT.FLAT);

		new Label(textNavigationComposite, SWT.NONE).setText(" ");

		Button nextText = new Button(textNavigationComposite, SWT.FLAT|SWT.PUSH);

		Button lastText = new Button(textNavigationComposite, SWT.FLAT|SWT.PUSH);

		textNavigationComposite.setLayoutData(new GridData(GridData.CENTER, GridData.FILL, false, false));

//		GridData buttonGridData = new GridData(GridData.END,GridData.CENTER, true, false);

//		buttonGridData.widthHint = 30;

//		buttonGridData.heightHint = 30;

//		firstText.setLayoutData(buttonGridData);

//		buttonGridData = new GridData(GridData.CENTER,GridData.CENTER, false, false);

//		buttonGridData.widthHint = 30;

//		buttonGridData.heightHint = 30;

//		previousText.setLayoutData(buttonGridData);

//		GridData centerButtonGridData = new GridData(GridData.END,GridData.CENTER, true, true);

//		centerButtonGridData.widthHint = 30;

//		centerButtonGridData.heightHint = 30;

//		first.setLayoutData(centerButtonGridData);

//		previous.setLayoutData(buttonGridData);

//		GridData gdata = new GridData(GridData.END,GridData.CENTER, false, false);

//		gdata.minimumWidth = 40;

//		gdata.widthHint = 40;

//		page_text.setLayoutData(gdata);

//		page_label.setLayoutData(new GridData(GridData.BEGINNING,GridData.CENTER, false, false));

//

//		next.setLayoutData(buttonGridData);

//		centerButtonGridData = new GridData(GridData.BEGINNING, GridData.CENTER, true, true);

//		centerButtonGridData.widthHint = 30;

//		centerButtonGridData.heightHint = 30;

//		last.setLayoutData(centerButtonGridData);

//		nextText.setLayoutData(buttonGridData);

//		lastText.setLayoutData(buttonGridData);

//		if (editionsChooser != null)

//			editionsChooser.setLayoutData(new GridData(GridData.BEGINNING,GridData.CENTER, false, true));

import java.util.Arrays;

		annotationWidgetGroup = toolbar.installAlternativesGroup("URS annotation", "Start URS annotation", IImageKeys.PENCIL_OPEN, IImageKeys.PENCIL_CLOSE, true, openCloseSelectionListener, Arrays.asList(modes), Arrays.asList(modeListeners));

		System.out.println("IsJFCComposite.test() recevier = " + receiver.getClass());

		System.out.println("IsJFCComposite.test() property = " + property);

		System.out.println("IsJFCComposite.test() args = " + args);

		System.out.println("IsJFCComposite.test() expectedValue = " + expectedValue);

            <visibleWhen

                  checkEnabled="false">

               <test

                     property="org.txm.chartsengine.enginetype"

                     value="true">

               </test>

            </visibleWhen>

   <extension

         point="org.eclipse.core.expressions.propertyTesters">

      <propertyTester

            class="org.txm.chartsengine.jfreechart.rcp.testers.__IsJFCComposite"

            id="org.txm.chartsengine.jfreechart.rcp.testers.__IsJFCComposite"

            namespace="org.txm.chartsengine"

            properties="enginetype"

            type="java.lang.Object">

      </propertyTester>

   </extension>

	private boolean inForm;

	private boolean mustChangeWordValue;

		} else if ("form".equals(localname) && inW) {

			if (currentTokenAnnotations.containsKey("word")) {

				Annotation a = currentTokenAnnotations.get("word");

				//System.out.println("Updating token annotation with: " + a);

				String value = a.getValue();

				if ("#del".equals(value))

					value = "";

				if (value == null)

					value = "ERROR";

				try {

					writer.writeStartElement("form");

					writer.writeCharacters(value);

					mustChangeWordValue = true;

				} catch (XMLStreamException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

				currentTokenAnnotations.remove("word"); // annotation updated

			} else {

				super.processStartElement();

			}

		} else if ("ana".equals(localname) && inW) {

		} else if (inW && mustChangeWordValue) {

			// nothing content is already written

			//System.out.println("skip form value because we replace it");

		} else if ("form".equals(localname) && inW) {

				mustChangeWordValue = false;

			inForm = false;

		} else if ("ana".equals(localname) && inW) {

			//if (!mustChangeAnaValue)

				super.processEndElement();

	public static void registerKnowledgeRepository(KnowledgeRepository kr) {

		repositories.put(kr.getName(), kr);

	}

   <extension-point id="org.txm.annotation.rcp.editor.AnnotationArea" name="org.txm.annotation.rcp.editor.AnnotationArea" schema="schema/org.txm.annotation.rcp.editor.AnnotationArea.exsd"/>

  <extension

        point="org.txm.annotation.rcp.editor.AnnotationArea">

     <annotationtoolbar

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

           position="3">

     </annotationtoolbar>

     <annotationtoolbar

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

           position="1">

     </annotationtoolbar>

     <annotationtoolbar

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

           position="2">

     </annotationtoolbar>

  </extension>

<?xml version='1.0' encoding='UTF-8'?>

<!-- Schema file written by PDE -->

<schema targetNamespace="org.txm.annotation.rcp" xmlns="http://www.w3.org/2001/XMLSchema">

<annotation>

      <appinfo>

         <meta.schema plugin="org.txm.annotation.rcp" id="org.txm.annotation.rcp.editor.AnnotationArea" name="org.txm.annotation.rcp.editor.AnnotationArea"/>

      </appinfo>

      <documentation>

         An annotation toolbar opened by the Annotation start button

      </documentation>

   </annotation>

   <element name="extension">

      <annotation>

         <appinfo>

            <meta.element />

         </appinfo>

      </annotation>

      <complexType>

         <choice minOccurs="1" maxOccurs="unbounded">

            <element ref="annotationtoolbar"/>

         </choice>

         <attribute name="point" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="id" type="string">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string">

            <annotation>

               <documentation>

               </documentation>

               <appinfo>

                  <meta.attribute translatable="true"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="annotationtoolbar">

      <complexType>

         <attribute name="class" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

               <appinfo>

                  <meta.attribute kind="java" basedOn="org.txm.annotation.rcp.editor.AnnotationArea:"/>

               </appinfo>

            </annotation>

         </attribute>

         <attribute name="position" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

               <appinfo>

                  <meta.attribute kind="java" basedOn="java.lang.Integer:"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <annotation>

      <appinfo>

         <meta.section type="since"/>

      </appinfo>

      <documentation>

         [Enter the first release in which this extension point appears.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="examples"/>

      </appinfo>

      <documentation>

         [Enter extension point usage example here.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="apiinfo"/>

      </appinfo>

      <documentation>

         [Enter API information here.]

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="implementation"/>

      </appinfo>

      <documentation>

         [Enter information about supplied implementation of this extension point.]

      </documentation>

   </annotation>

</schema>

import java.util.List;

import java.util.Locale;

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

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

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

public abstract class AnnotationArea<T extends TXMResult> {

	protected TXMEditor<T> editor;

	protected GLComposite annotationArea;

	public AnnotationArea() {

	 * TODO not done, should ask the 

	public String getLocale() {

		return Locale.getDefault().getCountry();

	}

	 * use this if you need something to be done when the extension is discovered

	 * 

	 * @throws Exception 

	public abstract boolean install(TXMEditor<? extends TXMResult> editor, Corpus corpus, Composite parent) throws Exception;

	public boolean close() {

		if (annotationArea != null && !annotationArea.isDisposed()) {

			annotationArea.dispose();

		}

		_close();

		return true;

	}

	protected abstract void _close();

	public abstract String getName();

	public GLComposite getAnnotationArea() {

		return annotationArea;

	/**

	 * Called BEFORE the TXMResult is computed

	 * 

	 * @return

	 * @throws Exception

	 */

	public abstract boolean notifyStartOfCompute() throws Exception;

	/**

	 * Called AFTER the TXMResult is computed

	 * @return

	 * @throws Exception

	 */

	public abstract boolean notifyEndOfCompute() throws Exception;

	public boolean isAnnotationEnable() {

		return annotationArea != null;

	}

	/**

	 * Called after the editor has been refreshed (after the result has been computed)

	 * 

	 * @param lines

	 * @param from

	 * @param to

	 * @throws Exception

	 */

	public abstract void update(List<Line> lines, int from, int to) throws Exception;

package org.txm.annotation.rcp.concordance;

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.IStructuredSelection;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TableViewerColumn;

import org.eclipse.swt.SWT;

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.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.Group;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.TableColumn;

import org.eclipse.swt.widgets.Text;

import org.eclipse.ui.dialogs.ListDialog;

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.KnowledgeRepository;

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

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

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.editor.AnnotationArea;

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

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.messages.ConcordanceUIMessages;

import org.txm.core.results.TXMResult;

import org.txm.rcp.IImageKeys;

import org.txm.rcp.editors.TXMEditor;

import org.txm.rcp.swt.GLComposite;

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.logger.Log;

public class SimpleKRAnnotation extends AnnotationArea<Concordance> {

	ConcordanceEditor editor;

	public SimpleKRAnnotation() {

	}

	/**

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

	 */

	protected static final int NALERTAFFECTANNOTATIONS = 100;

	public static final String EMPTYTEXT = "";

	/** The annotation service */

	protected AnnotationManager annotManager;

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

	protected Point annotationSize;

	protected Text annotationValuesText;

	protected ComboViewer annotationTypesCombo;

	protected TableColumn annotationColumn;

	protected Combo addRemoveCombo;

	protected Combo affectCombo;

	protected Button affectAnnotationButton;

	protected KnowledgeRepository currentKnowledgeRepository = null;

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

	protected Label withLabel;

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

	protected TypedValue value_to_add;

	protected Concordance concordance;

	private Corpus corpus;

	private ConcordanceAnnotations annotations = null;

	private Button addTypedValueLink;

	@Override

	public String getName() {

		return "Tag Annotation";

	}

	public boolean install(TXMEditor ceditor, final Corpus corpus, Composite parent) throws Exception{ 

		this.editor = (ConcordanceEditor)ceditor;

		this.corpus = corpus;

		this.concordance = editor.getConcordance();

		this.annotations = new ConcordanceAnnotations(editor.getConcordance());

		this.annotManager = KRAnnotationEngine.getAnnotationManager(corpus);

		TableViewer viewer = editor.getLineTableViewer();

		// RESULT

		int position = 3; // after keyword column

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

		annotationColumn = annotationColumnViewer.getColumn();

		annotationColumn.setText(ConcordanceUIMessages.ConcordancesEditor_15);

		annotationColumn.setToolTipText(ConcordanceUIMessages.ConcordancesEditor_17);

		annotationColumn.pack();

		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 == null) return EMPTYTEXT ;

				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 EMPTYTEXT;

				}

			}

		});

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

		typesList.clear();

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

		KnowledgeRepository kr  = KnowledgeRepositoryManager.getKnowledgeRepository(corpus.getMainCorpus().getName());

		if (kr == null) {

			HashMap<String, HashMap<String, ?>> conf = new HashMap<String, HashMap<String, ?>>();

			kr = KnowledgeRepositoryManager.createKnowledgeRepository(corpus.getMainCorpus().getName(), conf);

		}

		currentKnowledgeRepository = kr;

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

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

		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$

		}

		annotations.setViewAnnotation(tagAnnotationType);

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

		annotationArea = new GLComposite(parent, SWT.NONE, "Concordance Annotation area");

		annotationArea.getLayout().numColumns = 12;

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

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

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

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

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

		if (removeLabel == null) removeLabel= ConcordanceUIMessages.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(getLocale(), "ConcordancesEditor_83");

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

					withLabel.setText(withLabelText);

				} else { // remove

					annotationValuesText.setEnabled(false);

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

				}

				withLabel.redraw();

				annotationArea.layout();

				updateAnnotationWidgetStates();

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) { }

		});

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

		gdata.widthHint = 90;

		addRemoveCombo.setLayoutData(gdata);

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

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

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

		withLabel.setText(withLabelText);

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

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

		annotationValuesText.setToolTipText(ConcordanceUIMessages.ConcordancesEditor_32);

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

		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$

			addTypedValueLink.setToolTipText(ConcordanceUIMessages.ConcordancesEditor_77);

			addTypedValueLink.setEnabled(true);

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

			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());

					dialog.setTitle(ConcordanceUIMessages.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, false));

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

		affectCombo.setItems(items2);

		affectCombo.select(0);

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

		gdata.widthHint = 140;

		affectCombo.setLayoutData(gdata);

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

		affectAnnotationButton.setText(ConcordanceUIMessages.ConcordancesEditor_85);

		affectAnnotationButton.setToolTipText(ConcordanceUIMessages.ConcordancesEditor_116);

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

		affectAnnotationButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				int isel = affectCombo.getSelectionIndex();

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

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

				} else { // all

					try {

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

						affectMatchesToSelection(matches);

					} catch (CqiClientException e1) {

						Log.severe(ConcordanceUIMessages.ConcordancesEditor_53+e1);

						Log.printStackTrace(e1);

						return;

					}

				}

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) { }

		});

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

		saveAnnotationsButton.setToolTipText(ConcordanceUIMessages.ConcordancesEditor_76);

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

		saveAnnotationsButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				save();

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) { }

		});

		updateAnnotationWidgetStates();

		editor.layout(true);

		return true;

	}

	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(ConcordanceUIMessages.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(ConcordanceUIMessages.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 (addTypedValueLink != null) {

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

		}

	}

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

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

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

			return;

		}

		if (type == null) {

			return;

		}

		try {

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

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

				editor.refresh(false);

			} else {

				return;

			}

		} catch (Exception e1) {

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

			Log.printStackTrace(e1);

			return;

		}

		job.syncExec(new Runnable() {

			@Override

			public void run() {

				try {

					editor.refresh(false);

				} catch (Exception e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

		});

	}

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

		value_to_add = null; // reset

		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$

							ConcordanceUIMessages.ConcordancesEditor_86, 

							ConcordanceUIMessages.ConcordancesEditor_87+matches.size()+ConcordanceUIMessages.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(ConcordanceUIMessages.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(getLocale(), "ConcordancesEditor_110");

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

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

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

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

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

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

							ConcordanceUIMessages.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 = ConcordanceUIMessages.bind(ConcordanceUIMessages.ConcordancesEditor_58, svalue);

					System.out.println(mess);

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

				}

			});

			return;

		}

		Log.info(ConcordanceUIMessages.ConcordancesEditor_59+value_to_add+ConcordanceUIMessages.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 = ConcordanceUIMessages.ConcordancesEditor_61+value_to_add.getStandardName()+

						ConcordanceUIMessages.ConcordancesEditor_62;

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

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

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

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

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

						} else {

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

						}

					}

				}

				final String final_message = message;

				job.syncExec(new Runnable() {

					@Override

					public void run() {

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

					}

				});

			}

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

				annotManager.checkData();

			}

		} catch (Exception e1) {

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

			Log.printStackTrace(e1);

			return;

		}

		job.syncExec(new Runnable() {

			@Override

			public void run() {

				try {

					editor.refresh(false);

				} catch (Exception e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

		});

	}

	public boolean notifyStartOfCompute() throws Exception {

		if (annotationArea != null) {

			AnnotationType type = getSelectedAnnotationType();

			if (type != null) {

				annotations.setViewAnnotation(type);

				annotations.setAnnotationOverlap(true);

			}

		}

		return true;

	}

	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;

	}

	public void update(List<Line> lines, int from, int to) throws Exception {

		annotations.getLines(lines, from, to);

	}

	@Override

	public boolean save() {

		try {

			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$

				}

			}

		} catch(Exception ex) {

			ex.printStackTrace();

			return false;

		}

		return true;

	}

	@Override

	protected void _close() {

		annotationColumn.dispose();

	}

}

import java.util.Arrays;

import java.util.Comparator;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.Platform;

import org.txm.annotation.rcp.editor.AnnotationArea;

	protected AnnotationArea annotationArea;

	private SelectionListener defaultListener;

					return; // do nothing

					openDefaultAnnotationMode(e);