Laboratoire ICAR » Plateforme TXM

		to = Math.min(to, concordance.getNLines() - 1);

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

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.editors.ConcordanceEditorExtension;

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

import org.txm.core.preferences.TXMPreferences;

import org.txm.rcp.IImageKeys;

import org.txm.rcp.commands.OpenBrowser;

import org.txm.rcp.messages.TXMUIMessages;

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;

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

							}

						}

						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(ConcordanceUIMessages.ConcordancesEditor_15);

		annotationColumn.setToolTipText(ConcordanceUIMessages.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= ConcordanceUIMessages.ConcordancesEditor_22;

		String removeLabel = currentKnowledgeRepository.getString(editor.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(editor.getLocale(), "ConcordancesEditor_83");

					if (withLabelText == null) withLabelText= ConcordanceUIMessages.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= ConcordanceUIMessages.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(AnnotationUIMessages.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();

					}

					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(ConcordanceUIMessages.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(), ConcordanceUIMessages.ConcordancesEditor_82, ConcordanceUIMessages.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();

								}

								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= ConcordanceUIMessages.ConcordancesEditor_80;

			}

			valueLabel.setText(valueLabelText);

			valueLabel.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, 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(AnnotationUIMessages.AnnotationPreferences_2)) {

				addTypedValueLink.setToolTipText(ConcordanceUIMessages.ConcordancesEditor_79);

			} else {

				addTypedValueLink.setToolTipText(ConcordanceUIMessages.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(AnnotationUIMessages.AnnotationPreferences_2)) {

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

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

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

					} else {

						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, true));

		String items2[] = {ConcordanceUIMessages.ConcordancesEditor_35, ConcordanceUIMessages.ConcordancesEditor_42, ConcordanceUIMessages.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(ConcordanceUIMessages.ConcordancesEditor_85);

		affectAnnotationButton.setToolTipText(ConcordanceUIMessages.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(ConcordanceUIMessages.ConcordancesEditor_53+e1);

						Log.printStackTrace(e1);

						return;

					}

				} 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 cancelAnnotateButton = new Button(annotationArea, SWT.PUSH);

		cancelAnnotateButton.setText(ConcordanceUIMessages.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(ConcordanceUIMessages.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(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 (advanced_annotation_mode.equals(AnnotationUIMessages.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(ConcordanceUIMessages.ConcordancesEditor_54+e1);

				Log.printStackTrace(e1);

				return;

			}

			job.syncExec(new Runnable() {

				@Override

				public void run() {

					editor.fillDisplayArea();

					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$

							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(editor.getLocale(), "ConcordancesEditor_110");

					String content = kr.getString(editor.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 (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(ConcordanceUIMessages.ConcordancesEditor_74+e1);

			Log.printStackTrace(e1);

			return;

		}

		job.syncExec(new Runnable() {

			@Override

			public void run() {

				editor.fillDisplayArea();

				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;

	}

}

import java.io.IOException;

import java.util.Arrays;

import java.util.Collections;

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

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

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

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

		return lines; // TODO find a way to add 

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

		List<Annotation> annotationsPerMatch = null;;