Laboratoire ICAR » Plateforme TXM

            locationURI="menu:menu.file.import.annotations">

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import org.txm.Toolbox;

import org.txm.objects.Project;

	public boolean isSaveNeeded() {

		for (AnnotationEngine a : values()) {

			for (Project project : Toolbox.workspace.getProjects()) {

				for (CorpusBuild corpus : project.getCorpora()) {

					if (a.hasAnnotationsToSave(corpus)) {

						return true;

					}

				}

			}

		}

		return false;

	}

	public List<AnnotationEngine> getEnginesWithSaveNeeded() {

		List<AnnotationEngine> tmp = new ArrayList<AnnotationEngine>();

		for (AnnotationEngine a : values()) {

			for (Project project : Toolbox.workspace.getProjects()) {

				for (CorpusBuild corpus : project.getCorpora()) {

					if (a.hasAnnotationsToSave(corpus)) {

						tmp.add(a);

					}

				}

			}

		}

		return tmp;

	}

	public HashMap<CorpusBuild, ArrayList<AnnotationEngine>> getEnginesWithSaveNeededPerCorpus() {

		HashMap<CorpusBuild, ArrayList<AnnotationEngine>> tmp = new HashMap<CorpusBuild, ArrayList<AnnotationEngine>>();

		for (AnnotationEngine a : values()) {

			for (Project project : Toolbox.workspace.getProjects()) {

				for (CorpusBuild corpus : project.getCorpora()) {

					if (a.hasAnnotationsToSave(corpus)) {

						if (!tmp.containsKey(corpus)) tmp.put(corpus, new ArrayList<>());

						tmp.get(corpus).add(a);

					}

				}

			}

		}

		return tmp;

	}

import java.io.IOException;

import java.io.PrintWriter;

import java.nio.charset.Charset;

import java.util.Comparator;

import org.apache.commons.lang.StringUtils;

import org.osgi.service.prefs.BackingStoreException;

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

import org.txm.core.preferences.TBXPreferences;

import org.txm.core.preferences.TXMPreferences;

import org.txm.searchengine.cqp.AbstractCqiClient;

import org.txm.searchengine.cqp.CQPSearchEngine;

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

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

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

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

import org.txm.utils.CsvReader;

import org.txm.utils.io.IOUtils;

								(a.getStart() <= start && end <= a.getEnd()) ||

	public boolean exportAnnotationsToTable(File resultFile) throws Exception {

		final String encoding = TBXPreferences.getInstance().getString(TBXPreferences.EXPORT_ENCODING);

		String colseparator = TBXPreferences.getInstance().getString(TBXPreferences.EXPORT_COL_SEPARATOR);

		String txtseparator = TBXPreferences.getInstance().getString(TBXPreferences.EXPORT_TXT_SEPARATOR);

		List<String> krnames = KRAnnotationEngine.getKnowledgeRepositoryNames(corpus);

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

			Log.severe(NLS.bind("** Error: no knowledge repository found in {0} corpus.", corpus));

			throw new IllegalArgumentException("No kr in " + corpus);

		}

		String firtsKRName = krnames.get(0);

		KnowledgeRepository defaultKR = KRAnnotationEngine.getKnowledgeRepository(corpus, firtsKRName);

		if (defaultKR == null) {

			Log.severe(NLS.bind("** Error: no knowledge repository {0} found in {0} corpus.", defaultKR, corpus));

			throw new IllegalArgumentException("No kr " + defaultKR + " in " + corpus);

		}

		PrintWriter writer = IOUtils.getWriter(resultFile, encoding, false);

		String cols [] = {"text_id", "id", "end_id", "start", "end", "type", "value", "mode", "date", "annotator"};

		writer.println(StringUtils.join(cols, colseparator));

		if (this.getTemporaryManager().getAnnotations().size() == 0) {

			Log.warning("Warning: no annotations to export. Aborting.");

			return false;

		}

		String[] textsIds = corpus.getCorpusTextIdsList();

		int[] textsEndPositions = corpus.getTextEndLimits();

		HashMap<Integer, String> positions2Ids = new HashMap<Integer, String>();

		HashMap<Integer, String> positions2TextIds = new HashMap<Integer, String>();

		for (Annotation a : this.getTemporaryManager().getAnnotations()) {

			positions2Ids.put(a.getStart(), null);

			positions2Ids.put(a.getEnd(), null);

		}

		int[] positions = new int[positions2Ids.keySet().size()];

		int i = 0;

		for (int p : positions2Ids.keySet()) {

			positions[i++] = p;

		}

		String values[] = corpus.getProperty("id").cpos2Str(positions);

		for (i = 0 ; i < positions.length ; i++) {

			positions2Ids.put(positions[i], values[i]);

		}

		List<Annotation> annotations = this.getTemporaryManager().getAnnotations();

		annotations.sort(new Comparator<Annotation>() {

			@Override

			public int compare(Annotation arg0, Annotation arg1) {

				return arg0.getStart() - arg1.getStart();

			}

		});

		Log.info(NLS.bind("Exporting {0} annotations.", annotations.size()));

		ConsoleProgressBar cpb = new ConsoleProgressBar(annotations.size());

		int currentText = 0;

		for (Annotation a : annotations) {

			cpb.tick();

			// text_id	id	start	end	type	value	effect	date	annotator

			String effect = defaultKR.getType(a.getType()).getEffect().name();

			String startId = positions2Ids.get(a.getStart());

			String endId = positions2Ids.get(a.getEnd());

			while (textsEndPositions[currentText] < a.getStart()) {

				// System.out.println("currentText="+currentText+" a="+a.getStart()+" text start="+textsEndPositions[currentText]+" text id="+textsIds[currentText]);

				currentText++;// go to next text

			}

			String textid = textsIds[currentText];

			writer.println(

					txtseparator+textid.replace(txtseparator, txtseparator+txtseparator)				+txtseparator

					+colseparator+txtseparator+startId.replace(txtseparator, txtseparator+txtseparator)				+txtseparator

					+colseparator+txtseparator+endId.replace(txtseparator, txtseparator+txtseparator)				+txtseparator

					+colseparator+txtseparator+a.getStart()															+txtseparator

					+colseparator+txtseparator+a.getEnd()															+txtseparator

					+colseparator+txtseparator+a.getType().replace(txtseparator, txtseparator+txtseparator)			+txtseparator

					+colseparator+txtseparator+a.getValue().replace(txtseparator, txtseparator+txtseparator)		+txtseparator

					+colseparator+txtseparator+effect.replace(txtseparator, txtseparator+txtseparator)				+txtseparator

					+colseparator+txtseparator+a.getDate().replace(txtseparator, txtseparator+txtseparator)			+txtseparator

					+colseparator+txtseparator+a.getAnnotator().replace(txtseparator, txtseparator+txtseparator)	+txtseparator);

		}

		writer.close();

		cpb.done();

		return true;

	}

	public boolean importAnnotationsFromTable(File annotationsFile) throws Exception {

		if (!isOpen()) {

			this.initialize();

		}

		final String encoding = TBXPreferences.getInstance().getString(TBXPreferences.EXPORT_ENCODING);

		String colseparator = TBXPreferences.getInstance().getString(TBXPreferences.EXPORT_COL_SEPARATOR);

		String txtseparator = TBXPreferences.getInstance().getString(TBXPreferences.EXPORT_TXT_SEPARATOR);

		List<String> krnames = KRAnnotationEngine.getKnowledgeRepositoryNames(corpus);

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

			Log.severe(NLS.bind("** Error: no knowledge repository found in {0} corpus.", corpus));

			throw new IllegalArgumentException("No kr in " + corpus);

		}

		String firtsKRName = krnames.get(0);

		KnowledgeRepository defaultKR = KRAnnotationEngine.getKnowledgeRepository(corpus, firtsKRName);

		if (defaultKR == null) {

			Log.severe(NLS.bind("** Error: no knowledge repository {0} found in {0} corpus.", defaultKR, corpus));

			throw new IllegalArgumentException("No kr " + defaultKR + " in " + corpus);

		}

		CsvReader reader = new CsvReader(annotationsFile.getAbsolutePath(), colseparator.charAt(0), Charset.forName(encoding));

		if (txtseparator.length() > 0) reader.setTextQualifier(txtseparator.charAt(0));

		reader.readHeaders();

		String headers [] = reader.getHeaders();

		String cols [] = {"text_id", "id", "end_id", "start", "end", "type", "value", "mode", "date", "annotator"};

		if (headers.length != cols.length) {

			Log.warning("Error: annotation file header format is not well-formatted: "+StringUtils.join(headers, ", ")+". Should be: "+StringUtils.join(cols, ", "));

			return false;

		}

		for (int i = 0 ; i < cols.length ; i++) {

			if (!(headers[i].equals(cols[i]))) {

				Log.warning("Error: annotation file header format is not well-formatted: "+StringUtils.join(headers, ", ")+". Should be: "+StringUtils.join(cols, ", "));

				return false;

			}

		}

		int nLines = 0;

		while (reader.readRecord()) {

			nLines++;

		}

		reader.close();

		if (nLines == 0) {

			Log.warning("Error: no annotation line found");

			return false;

		}

		Log.info(NLS.bind("Importing {0} annotations...", nLines));

		reader = new CsvReader(annotationsFile.getAbsolutePath(), colseparator.charAt(0), Charset.forName(encoding));

		if (txtseparator.length() > 0) reader.setTextQualifier(txtseparator.charAt(0));

		reader.readHeaders();

		ConsoleProgressBar cpb = new ConsoleProgressBar(nLines);

		this.tempManager.getEntityManager().getTransaction().begin();

		while (reader.readRecord()) {

			cpb.tick();

			String[] record = reader.getValues();

			String typeName = record[5].trim();

			String typeEffect = record[7].trim();

			if (defaultKR.getType(typeName) == null) {

				defaultKR.addType(typeName, typeName, null, AnnotationEffect.valueOf(typeEffect));

			}

			AnnotationType type = defaultKR.getType(typeName);

			String startId = record[1].trim();

			String endId = record[2].trim();

			int startPos = -1;

			int endPos = -1;

			if (startId.length() > 0 && endId.length() > 0) { // use the word id if present

				String textId = record[0].trim();

				if (startId.equals(endId)) {

					CQLQuery cql = new CQLQuery(NLS.bind("[id=\"{0}\" & _.text_id=\"{1}\"]", startId, textId));

					QueryResult qr = corpus.query(cql , "TMP", false);

					if (qr.getNMatch() == 0) {

						Log.warning("No match found with CQL="+cql);

						continue;

					}

					startPos = qr.getMatch(0).getStart();

					endPos = startPos;

				} else {

					CQLQuery cql = new CQLQuery(NLS.bind("[id=\"{0}\" & _.text_id=\"{1}\"]", startId, textId));

					QueryResult qr = corpus.query(cql , "TMP", false);

					if (qr.getNMatch() == 0) {

						Log.warning("No match found with CQL="+cql);

						continue;

					}

					startPos = qr.getMatch(0).getStart();

					qr.drop();

					cql = new CQLQuery(NLS.bind("[id=\"{0}\" & _.text_id=\"{1}\"]", endId, textId));

					qr = corpus.query(cql , "TMP", false);

					if (qr.getNMatch() == 0) {

						Log.warning("No match found with CQL="+cql);

						continue;

					}

					endPos = qr.getMatch(0).getStart();

					qr.drop();

				}

			} else {

				startPos = Integer.parseInt(record[3]);

				endPos = Integer.parseInt(record[4]);

			}

			if (type.getTypedValue(record[6]) == null) {

				defaultKR.addValue(record[6], record[6], typeName);

			}

			TypedValue value = type.getTypedValue(record[6]);

			List<Annotation> a = this.tempManager.createAnnotationNoCommit(type, value, startPos, endPos);

		}

		this.tempManager.getEntityManager().getTransaction().commit();

		cpb.done();

		return true;

	}

	private EntityManagerFactory emf;

		if (emf != null) {

			emf.close();

		}

		String query = "SELECT annot FROM Annotation AS annot WHERE annot.PK.refType LIKE '" + refType.getId() + "'";

		emf = pp.createEntityManagerFactory(DatabasePersistenceManager.PERSISTENCE_UNIT_NAME, properties);

import org.txm.annotation.kr.core.preferences.KRAnnotationPreferences;

		if (r instanceof MainCorpus && "before_clean".equals(state)) {

				Log.fine("closing temporary annotations database of: "+c);

		} else if (r instanceof MainCorpus && "clean".equals(state)) {

			MainCorpus c = (MainCorpus) r;

			if (c.getProject() == null || c.getProject().getDoUpdate()) {

				return;

			}

			for (String krname : KRAnnotationEngine.getKnowledgeRepositoryNames(c)) {

				Log.fine("cleaning KR: " + krname);

				KRAnnotationEngine.unregisterKnowledgeRepositoryName(c, krname);

			}

			if (c.getProjectDirectory() == null || !c.getProjectDirectory().exists()) {

				return;

			}

			if (ams.get(c) != null && ams.get(c).tempManager != null && ams.get(c).tempManager.getEntityManager() != null ) {

				Log.fine("closing temporary annotations databse of: "+c);

				ams.get(c).tempManager.close(); // free files

			}

			File buildDirectory = new File(c.getProjectDirectory(), "temporary_annotations/" + c.getID());

			if (buildDirectory.exists()) {

				DeleteDir.deleteDirectory(buildDirectory);

			}

		if (KRAnnotationPreferences.getInstance().getBoolean(KRAnnotationPreferences.PRESERVE_ANNOTATIONS)) return false;

		kr.close();

	private EntityManagerFactory emf;

//				Log.warning("KR Annotation Types already exist:");

//				for (AnnotationType annotType : annotTypes) {

//					Log.warning(NLS.bind(" - Type : {0}", annotType.getName()));

//				}

	public void close() {

		if (jpaem != null) jpaem.close();

		if (emf != null) emf.close();

	}

		Toolbox.notifyEngines(this, "before_clean"); // if an extension needs to free some files before

//		ext.getSaveButton().setEnabled(true);

		return annotManager != null && annotManager.isDirty();

//		ext.getSaveButton().setEnabled(true);

//		ext.getSaveButton().setEnabled(true);

// Copyright © 2010-2020 ENS de Lyon., University of Franche-Comté

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.annotation.kr.rcp.commands;

import java.io.File;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.FileDialog;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.handlers.HandlerUtil;

import org.txm.Toolbox;

import org.txm.annotation.kr.core.AnnotationManager;

import org.txm.annotation.kr.core.KRAnnotationEngine;

import org.txm.rcp.StatusLine;

import org.txm.rcp.messages.TXMUIMessages;

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

import org.txm.rcp.utils.JobHandler;

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

import org.txm.utils.logger.Log;

/**

 * Open a file in the TxtEditor 

 * 

 * @author mdecorde.

 */

public class ExportTable extends AbstractHandler {

	public static final String ID = ExportTable.class.getCanonicalName();

	/* (non-Javadoc)

	 * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		ISelection sel = (IStructuredSelection) HandlerUtil.getCurrentSelection(event);

		if (!(sel instanceof IStructuredSelection)) return null;

		IStructuredSelection selection = (IStructuredSelection) sel;

		Object s = selection.getFirstElement();

		if (!(s instanceof MainCorpus)) {

			Log.warning(NLS.bind("Selection is not a Corpus: {0}. Aborting.", s));

			return null;

		}

		Shell shell = HandlerUtil.getActiveWorkbenchWindowChecked(event).getShell();

		//FileDialog dialog = new FileDialog(shell, SWT.SAVE);

		FileDialog dialog = new FileDialog(shell, SWT.SAVE);

		MainCorpus corpus = (MainCorpus) s;

		String path = Toolbox.getTxmHomePath();

		dialog.setFilterPath(path); //To set a specific path

		dialog.setFileName(corpus.getID()+"_annotations.csv");

		dialog.setFilterExtensions(new String[]{"*.csv", "*.tsv"});

		if (dialog.open() != null) {

			StatusLine.setMessage(TXMUIMessages.exportingAnnotations);

			String filepath = dialog.getFilterPath();

			String filename = dialog.getFileName();

			final File resultFile = new File(filepath, filename);

			LastOpened.set(ID, resultFile.getParent(), resultFile.getName());

			try {

				exportAnnotations(corpus, resultFile);

			} catch (Exception e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

				return null;

			}

		}

		return corpus;

	}

	public static boolean exportAnnotations(final MainCorpus corpus, final File resultFile) throws Exception {

		final AnnotationManager am = KRAnnotationEngine.getAnnotationManager(corpus);

		if (am == null) return true; // nothing to do

		JobHandler jobhandler = new JobHandler("Exporting annotations in table for "+corpus) { //$NON-NLS-1$

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				this.runInit(monitor);

				try {

					monitor.beginTask("Exporting annotations as standoff", 100);

					monitor.setTaskName("Writing annotations in the table file: "+resultFile);

					/*if (MessageDialog.openConfirm(Display.getCurrent().getActiveShell(), "Before saving annotations...", "All editors using this corpus are going to be closed. Continue ?")) {

						return false;

					}*/

					///lecture de tous les fichiers un par un

					///chaque annotation est récupérée et selon l'annotateur, écrite dans un fichier spécifique à celui-ci

					if (!am.exportAnnotationsToTable(resultFile)) {

						Log.warning("Error while exporting annotations (see logs above).");

						return Status.CANCEL_STATUS;

					}

					monitor.worked(30);

					Log.info("Done.");

				} catch(Exception e) {

					Log.warning(NLS.bind("Error while saving annotations: {0}.", e));

					Log.printStackTrace(e);

					return Status.CANCEL_STATUS;

				}

				return Status.OK_STATUS;

			}

		};

		jobhandler.startJob(true);

		return true;

	}

}

// Copyright © 2010-2020 ENS de Lyon., University of Franche-Comté

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.annotation.kr.rcp.commands;

import java.io.File;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.FileDialog;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.handlers.HandlerUtil;

import org.txm.Toolbox;

import org.txm.annotation.kr.core.AnnotationManager;

import org.txm.annotation.kr.core.KRAnnotationEngine;

import org.txm.rcp.StatusLine;

import org.txm.rcp.messages.TXMUIMessages;

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

import org.txm.rcp.utils.JobHandler;

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

import org.txm.utils.logger.Log;

/**

 * Open a file in the TxtEditor 

 * 

 * @author mdecorde.

 */

public class ImportTable extends AbstractHandler {

	public static final String ID = ImportTable.class.getCanonicalName();

	/* (non-Javadoc)

	 * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		ISelection sel = (IStructuredSelection) HandlerUtil.getCurrentSelection(event);

		if (!(sel instanceof IStructuredSelection)) return null;

		IStructuredSelection selection = (IStructuredSelection) sel;

		Object s = selection.getFirstElement();

		if (!(s instanceof MainCorpus)) {

			Log.warning(NLS.bind("Selection is not a Corpus: {0}. Aborting.", s));

			return null;

		}

		Shell shell = HandlerUtil.getActiveWorkbenchWindowChecked(event).getShell();

		//FileDialog dialog = new FileDialog(shell, SWT.SAVE);

		FileDialog dialog = new FileDialog(shell, SWT.OPEN);

		MainCorpus corpus = (MainCorpus) s;

		String path = Toolbox.getTxmHomePath();

		dialog.setFilterPath(path); //To set a specific path

		dialog.setFileName(corpus.getID()+"_annotations.csv");

		dialog.setFilterExtensions(new String[]{"*.csv", "*.tsv"});

		if (dialog.open() != null) {

			StatusLine.setMessage(TXMUIMessages.exportingAnnotations);

			String filepath = dialog.getFilterPath();

			String filename = dialog.getFileName();

			final File resultFile = new File(filepath, filename);

			LastOpened.set(ID, resultFile.getParent(), resultFile.getName());

			try {

				importAnnotations(corpus, resultFile);

			} catch (Exception e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

				return null;

			}

		}

		return corpus;

	}

	public static boolean importAnnotations(final MainCorpus corpus, final File annotationsFile) throws Exception {

		final AnnotationManager am = KRAnnotationEngine.getAnnotationManager(corpus);

		if (am == null) return true; // nothing to do

		JobHandler jobhandler = new JobHandler("Importing annotations in table for "+corpus) { //$NON-NLS-1$

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				this.runInit(monitor);

				try {

					monitor.beginTask("Importing annotations as standoff", 100);

					monitor.setTaskName("Reading annotations in the table file: "+annotationsFile);

					/*if (MessageDialog.openConfirm(Display.getCurrent().getActiveShell(), "Before saving annotations...", "All editors using this corpus are going to be closed. Continue ?")) {

						return false;

					}*/

					///lecture de tous les fichiers un par un

					///chaque annotation est récupérée et selon l'annotateur, écrite dans un fichier spécifique à celui-ci

					if (!am.importAnnotationsFromTable(annotationsFile)) {

						Log.warning("Error while importing annotations (see logs above).");

						return Status.CANCEL_STATUS;

					}

					monitor.worked(30);

					Log.info("Done.");

				} catch(Exception e) {

					Log.warning(NLS.bind("Error while importing annotations: {0}.", e));

					Log.printStackTrace(e);

					return Status.CANCEL_STATUS;

				}

				return Status.OK_STATUS;

			}

		};

		jobhandler.startJob(true);

		return true;

	}

}

	 * Add a new annotation type or value.

//		ext.getSaveButton().setEnabled(true);

command.label.1=Annotations CQP au format Table (.csv)...

command.label.1=CQP Annotations in Table format (.csv)

      <command

            defaultHandler="org.txm.annotation.kr.rcp.commands.ExportTable"

            id="org.txm.annotation.kr.rcp.commands.ExportTable"

            name="Export in table">

      </command>

      <command

            defaultHandler="org.txm.annotation.kr.rcp.commands.ImportTable"

            id="org.txm.annotation.kr.rcp.commands.ImportTable"

            name="Import from table">

      </command>

           locationURI="menu:menu.file.export.properties">

        <command

              commandId="org.txm.rcp.commands.annotation.ExportStandoff"

              id="menu.file.export.exporttei"

              label="%command.label.0"

              style="push">

           <visibleWhen

                 checkEnabled="false">

              <reference

                    definitionId="OneMainCorpusSelected">

              </reference>

           </visibleWhen>

        </command>

     </menuContribution>

     <menuContribution

           allPopups="false"

                 commandId="org.txm.annotation.kr.rcp.commands.ExportTable"

                 id="menu.file.export.exporttable"

                 label="%command.label.1"

                 style="push">

              <visibleWhen

                    checkEnabled="false">

                 <reference

                       definitionId="OneMainCorpusSelected">

                 </reference>

              </visibleWhen>

           </command>

                  label="%command.label.0"

            <command

                  commandId="org.txm.annotation.kr.rcp.commands.ExportTable"

                  label="%command.label.1"

                  style="push">

               <visibleWhen

                     checkEnabled="false">

                  <reference

                        definitionId="OneMainCorpusSelected">

                  </reference>

               </visibleWhen>

            </command>

     <menuContribution

           locationURI="menu:menu.file.import.annotations">

        <command

              commandId="org.txm.annotation.kr.rcp.commands.ImportTable"

              label="CQP Annotation from Table (.csv)"

              style="push">

           <visibleWhen

                 checkEnabled="false">

              <reference

                    definitionId="OneMainCorpusSelected">

              </reference>

           </visibleWhen>

        </command>

     </menuContribution>

               OSGI-INF/,\

               OSGI-INF/l10n/bundle.properties

Bundle-Name = XmlEditorRCP

command.label.0 = Open the XML-TEI TXM file

command.label.0 = Ouvrir le fichier XML-TEI TXM

               label="%command.label.0"

               label="%command.label.0"

import org.eclipse.jface.dialogs.MessageDialog;

	public int ALERT = 1000;

				if (txmFile.length() > ALERT) {

					if (!MessageDialog.openQuestion(shell, "Big file /o\\", txmFile.getAbsolutePath()+" is a very big file. Do you want to continue and opens it?")) {

						Log.info("Aborting the opening of "+txmFile);

						return null;

					}

				}

					System.out.println("Word selection identifiers: " + line.getKeywordIds());

            locationURI="menu:menu.file.export.corpus">

	//private ToolItem saveButton;

//	/**

//	 * use this to enable/disable the button

//	 * 

//	 * @return

//	 */

//	public ToolItem getSaveButton() {

//		return saveButton;

//	}

//		saveButton = new ToolItem(editor.getTopToolbar(), SWT.PUSH);

//		saveButton.setText("Save annotations");

//		//saveButton.setImage(IImageKeys.getImage(IImageKeys.PENCIL_SAVE));

//		saveButton.addSelectionListener(new SelectionListener() {

//			

//			@Override

//			public void widgetSelected(SelectionEvent e) {

//				try {

//					notifyDoSave();

//				}

//				catch (Exception e1) {

//					Log.printStackTrace(e1);

//				}

//			}

//			

//			@Override

//			public void widgetDefaultSelected(SelectionEvent e) {}

//		});

//		saveButton.setEnabled(false);

//		saveButton.setEnabled(false);

		return false;

//		boolean dirty = false;

//		for (AnnotationArea aa : annotationAreas) {

//			dirty = dirty || aa.isDirty();

//		}

//		return dirty;

//		JobHandler job = new JobHandler("Updating corpus indexes and editions", true) {

//			

//			@Override

//			protected IStatus run(IProgressMonitor monitor) {

//				

//				this.runInit(monitor);

//				

//				try {

//					monitor.setTaskName("Updating corpus XML-TXM files");

//					

//					Log.info("Saving annotations...");

//					boolean needToUpdateIndexes = false;

//					boolean needToUpdateEditions = false;

//					// System.out.println("Saving annotations...");

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

//						for (AnnotationArea aa : annotationAreas) {

//							needToUpdateIndexes = needToUpdateIndexes 

//									|| (aa.isDirty() 

//											&& aa.save()

//											&& aa.needToUpdateIndexes());

//							needToUpdateEditions = needToUpdateEditions || aa.needToUpdateEditions();

//						}

//					}

//					

//					if (needToUpdateIndexes) {

//						final MainCorpus corpus = editor.getResult().getFirstParent(MainCorpus.class);

//						monitor.setTaskName("Updating corpus indexes and editions");

//						if (corpus != null && UpdateCorpus.update(corpus, needToUpdateEditions) != null) {

//							monitor.worked(50);

//							this.syncExec(new Runnable() {

//								

//								@Override

//								public void run() {

//									Log.info("Done.");

//									CorporaView.refreshObject(corpus);

//									if (!saveButton.isDisposed()) {

//										saveButton.setEnabled(false);

//									}

//								}

//							});

//							return Status.OK_STATUS;

//						}

//						else {

//							monitor.worked(50);

//							Log.warning("Fail to update corpus. Aborting");

//							Log.warning("Fix XML-TXM files and call command 'UpdateCorpus'");

//							return Status.CANCEL_STATUS;

//						}

//					} else {

//						this.syncExec(new Runnable() {

//							

//							@Override

//							public void run() {

//								Log.info("Done.");

//								if (!saveButton.isDisposed()) {

//									saveButton.setEnabled(false);

//								}

//							}

//						});

//						return Status.OK_STATUS;

//					}

//				} catch(ThreadDeath ex) {

//					Log.warning(TXMUIMessages.executionCanceled);

//					return Status.CANCEL_STATUS;

//				}

//			}

//		};

//		job.schedule();

//		try {

//			boolean annotationsDirty = false;

//			for (AnnotationArea aa : annotationAreas) {

//				annotationsDirty = annotationsDirty || aa.isDirty();

//			}

//			if (annotationsDirty) {

//				boolean doSave = MessageDialog.openQuestion(this.editor.getShell(), "Annotations not saved", "Do you want to save the annotations before closing the editor?");

//				if (doSave) {

//					notifyDoSave();

//				}

//			}

//		} catch(Exception e) {

//			Log.printStackTrace(e);

//		}