Laboratoire ICAR » Plateforme TXM

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

<projectDescription>

	<name>org.txm.annotation.rcp</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.ManifestBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.SchemaBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.pde.PluginNature</nature>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

package org.txm.annotation.rcp.commands;

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.dialogs.MessageDialog;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.MessageBox;

import org.eclipse.ui.handlers.HandlerUtil;

import org.txm.annotation.core.AnnotationManager;

import org.txm.annotation.core.KRAnnotationEngine;

import org.txm.rcp.Messages;

import org.txm.rcp.commands.CloseEditorsUsing;

import org.txm.rcp.commands.workspace.UpdateCorpus;

import org.txm.rcp.utils.JobHandler;

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

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

import org.txm.utils.logger.Log;

public class SaveAnnotations extends AbstractHandler {

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

	@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))

			return null;

		MainCorpus corpus = (MainCorpus) s;

		save(corpus);

		return corpus;

	}

	public static JobHandler save(final MainCorpus corpus) {

		final AnnotationManager am = KRAnnotationEngine.getAnnotationManager(corpus);

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

		if (!KRAnnotationEngine.needToSaveAnnotations(corpus)) {

			return null;

		}

		//System.out.println("DISPLAY="+Display.getDefault());

		Display.getDefault().syncExec(new Runnable() {

			@Override

			public void run() {

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

					return;

				}

			}

		});

		JobHandler jobhandler = new JobHandler("Saving annotations of "+corpus) { //$NON-NLS-1$

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				this.runInit(monitor);

				try {

					monitor.beginTask("Saving annotations", 100);

					monitor.setTaskName("writing annotations in XML-TXM files");

					boolean rez = am.saveAnnotations();

					monitor.worked(30);

					if (rez) {

						System.out.println("Annotations are saved in XML-TXM files. Updating corpus indexes and editions");

						monitor.setTaskName("updating corpus indexes and editions");

						if (UpdateCorpus.update(corpus) != null) {

							monitor.worked(50);

							this.syncExec(new Runnable() {

								public void run() {CorporaView.refreshObject(corpus);}

							});

						} else {

							monitor.worked(50);

							System.out.println("Fail to update corpus. Aborting");

							System.out.println("Fix XML-TXM files and call command 'UpdateCorpus'");

						}

					} else {

						System.out.println("Error while saving annotations (see logs above).");

					}

				} catch(Exception e) {

					System.out.println("Error while saving annotations: "+e);

					Log.printStackTrace(e);

					return Status.CANCEL_STATUS;

				}

				return Status.OK_STATUS;

			}

		};

		jobhandler.startJob(true);

		return jobhandler;

	}

}

package org.txm.annotation.rcp.commands;

import java.io.File;

import java.io.IOException;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.logging.Level;

import java.util.regex.Pattern;

import javax.xml.stream.XMLStreamException;

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.swt.widgets.Display;

import org.eclipse.ui.handlers.HandlerUtil;

import org.kohsuke.args4j.Option;

import org.txm.Toolbox;

import org.txm.annotation.core.conversion.CorpusRuledConvertion;

import org.txm.core.preferences.TBXPreferences;

import org.txm.importer.ImportKeys;

import org.txm.objects.BaseParameters;

import org.txm.rcp.commands.CloseEditorsUsing;

import org.txm.rcp.commands.ExecuteImportScript;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

import org.txm.rcp.utils.JobHandler;

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

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

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

import org.txm.utils.logger.Log;

public class RecodeCorpus extends AbstractHandler {

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

	@Option(name="conversionFile", usage="conversionFile", widget="File", required=true, def="conv.tsv")

	protected File conversionFile;

	@Option(name="oldType", usage="oldType", widget="String", required=true, def="pos")

	protected String oldType;

	@Option(name="newType", usage="newType", widget="String", required=true, def="pos2")

	protected String newType;

	@Option(name="gestionInconnus", usage="oldType", widget="String", required=true, def="abandon")

	protected String gestionInconnus;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		ISelection isel = HandlerUtil.getCurrentSelection(event);

		if (isel == null) return null ;

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

		IStructuredSelection selection = (IStructuredSelection) isel;

		Object s = selection.getFirstElement();

		if (!(s instanceof MainCorpus)) return null;

		final MainCorpus corpus = (MainCorpus) s;

		try {

			if (ParametersDialog.open(this)) {

				JobHandler job = new JobHandler("Recode corpus "+corpus) {

					@Override

					protected IStatus run(IProgressMonitor monitor) {

						try {

							recode(corpus, conversionFile, oldType, newType, monitor);

						} catch (Exception e) {

							System.out.println("Fail to convert properties of corpus "+corpus);

							e.printStackTrace();

							return Status.CANCEL_STATUS;

						}

						return Status.OK_STATUS;

					}

				};

				job.startJob();

				return corpus;

			}

		} catch (Exception e) {

			e.printStackTrace();

		}

		return corpus;

	}

	public static JobHandler recode(final MainCorpus corpus, CorpusRuledConvertion crc, String oldType, String newType, IProgressMonitor monitor) throws IOException, CqiClientException, XMLStreamException {

		Property p1 = corpus.getProperty(oldType);

		if (p1 == null) {

			System.out.println("Corpus "+corpus+" has not property "+oldType);

			return null;

		}

		System.out.println("Recoding "+corpus+" property "+oldType+" in "+newType);

		monitor.beginTask("Recoding corpus properties...", 2);

		monitor.setTaskName("Recoding XML-TXM files");

		// apply conversion file

		if (!crc.process(corpus)) {

			System.out.println("Failed to edit XML-TXM of the corpus: "+corpus);

			return null;

		}

		monitor.worked(1);

		// update corpus indexes and edition

		String txmhome = Toolbox.getParam(TBXPreferences.USER_TXM_HOME);

		BaseParameters params = corpus.getBase().getBaseParameters();

		params.getKeyValueParameters().put(ImportKeys.MULTITHREAD, "false"); //too soon

		params.getKeyValueParameters().put(ImportKeys.DEBUG, Log.getLevel().intValue() < Level.WARNING.intValue()); // need debug for experimental stuff

		params.getKeyValueParameters().put(ImportKeys.UPDATECORPUS, "true");

		monitor.setTaskName("Updating corpus");

		File scriptDir = new File(txmhome, "scripts/import");

		File script = new File(scriptDir, "xtzLoader.groovy");

		System.out.println("Updating corpus "+corpus+" using "+params.paramFile);

		JobHandler ret = ExecuteImportScript.executeScript(script.getAbsolutePath(), params);

		Display.getDefault().syncExec(new Runnable() {

			@Override

			public void run() {CloseEditorsUsing.corpus(corpus);}

		});

		monitor.worked(1);

		return ret;

	}

	public static JobHandler recode(final MainCorpus corpus, LinkedHashMap<Pattern, String> rules, String oldType, String newType, IProgressMonitor monitor) throws IOException, CqiClientException, XMLStreamException {

		// apply conversion file

		CorpusRuledConvertion crc = new CorpusRuledConvertion(rules, newType, oldType);

		return recode(corpus, crc, oldType, newType , monitor);

	}

	public static JobHandler recode(final MainCorpus corpus, File conversionFile, String oldType, String newType, IProgressMonitor monitor) throws IOException, CqiClientException, XMLStreamException {

		System.out.println("Create CorpusRuledConvertion with "+conversionFile);

		// apply conversion file

		CorpusRuledConvertion crc = new CorpusRuledConvertion(conversionFile, oldType, newType);

		return recode(corpus, crc, oldType, newType, monitor);

	}

}

package org.txm.annotation.rcp.commands;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.handlers.HandlerUtil;

import org.txm.annotation.core.KRAnnotationEngine;

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

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

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

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

public class InitializeKnowledgeRepository extends AbstractHandler {

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

	@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))

			return null;

		MainCorpus corpus = (MainCorpus) s;

		return get(corpus);

	}

	/**

	 * Use this method to set eventual login+password needed by SQL knowledge repositories

	 * 

	 * @param corpus

	 * @return

	 */

	public static List<KnowledgeRepository> get(MainCorpus corpus) {

		List<KnowledgeRepository> ret = new ArrayList<KnowledgeRepository>();

		for (String kr_name : KRAnnotationEngine.getKnowledgeRepositoryNames(corpus)) {

			KnowledgeRepository kr = KRAnnotationEngine.getKnowledgeRepository(corpus, kr_name);

			if (kr == null) {

				System.out.println("Warning '"+kr_name+"' KR is null. Please check KR configuration.");

				continue;

			}

			//System.out.println("IS CREDENTIAL NEEDED: "+kr_name+" "+corpus);

			boolean[] must = KnowledgeRepositoryManager.mustLoginToKnowledgeRepository(kr_name, corpus);

			if (must[0] || must[1]) {

				System.out.println("Asking credentials for "+kr_name+" KR login");

				UsernamePasswordDialog dialog = new UsernamePasswordDialog(Display.getCurrent().getActiveShell(), must, kr_name);

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

					System.out.println("Temporary save login+password");

					System.setProperty(KnowledgeRepository.LOGIN_KEY+kr_name, dialog.getUser());

					System.setProperty(KnowledgeRepository.PASSWORD_KEY+kr_name, dialog.getPassword());

				} else {

					System.out.println("Cancelling login for "+kr_name+" KR");

					continue; // ignoring

				}

			}

			if (!kr.checkConnection()) {

				System.out.println("Error during connection to '"+kr_name+"'. Please check login, password and Internet connection.");

			} else {

				ret.add(kr);

			}

		}

		return ret;

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// 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.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.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.core.AnnotationManager;

import org.txm.annotation.core.KRAnnotationEngine;

import org.txm.core.preferences.TBXPreferences;

import org.txm.rcp.Messages;

import org.txm.rcp.StatusLine;

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;

// TODO: Auto-generated Javadoc

/**

 * Open a file in the TxtEditor @ author mdecorde.

 */

public class ExportStandoff extends AbstractHandler {

	public static final String ID = ExportStandoff.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)) {

			System.out.println("Selection is not a Corpus. Aborting.");

			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.getParam(TBXPreferences.USER_TXM_HOME);

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

		dialog.setFileName(corpus.getName()+"_annotations.zip");

		dialog.setFilterExtensions(new String[]{"*.zip"});

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

			StatusLine.setMessage(Messages.ExportAnnotation_0);

			String filepath = dialog.getFilterPath();

			String filename = dialog.getFileName();

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

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

			exportAnnotations(corpus, resultZipFile);

		}

		return corpus;

	}

	public static boolean exportAnnotations(final MainCorpus corpus, final File resultZipFile) {

		final AnnotationManager am = KRAnnotationEngine.getAnnotationManager(corpus);

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

		JobHandler saveJob = SaveAnnotations.save(corpus);

		if (saveJob != null)

			try {

				saveJob.join();

			} catch (InterruptedException e1) {

				// TODO Auto-generated catch block

				e1.printStackTrace();

			}

		JobHandler jobhandler = new JobHandler("Exporting annotations as standoff 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 XML-TXM stand-off files");

					/*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.exportAnnotationsToSyMoGIH(resultZipFile)) {

						System.out.println("Error while saving stand-off annotations (see logs above).");

						return Status.CANCEL_STATUS;

					}

					monitor.worked(30);

					System.out.println("Done.");

				} catch(Exception e) {

					System.out.println("Error while saving annotations: "+e);

					Log.printStackTrace(e);

					return Status.CANCEL_STATUS;

				}

				return Status.OK_STATUS;

			}

		};

		jobhandler.startJob(true);

		return true;

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// 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.rcp.commands.krview;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.ui.handlers.HandlerUtil;

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

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

/**

 * Reloads a KnowledgeRepository

 */

public class Reload extends AbstractHandler {

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		IStructuredSelection selection = (IStructuredSelection) HandlerUtil.getCurrentSelection(event);

//		System.out.println("Reload: "+selection);

		reload(selection);

		return null;

	}

	/**

	 * Copy.

	 *

	 * @param selection the selection

	 */

	public static void reload(IStructuredSelection selection)

	{

		Object selectedItem = selection.getFirstElement();

		if (selectedItem instanceof KnowledgeRepository) {

			((KnowledgeRepository)selectedItem).reload();

			KRView.refresh();

		}

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// 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.rcp.commands.krview;

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.jface.dialogs.InputDialog;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.handlers.HandlerUtil;

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.views.knowledgerepositories.KRView;

import org.txm.utils.AsciiUtils;

// TODO: Auto-generated Javadoc

/**

 * Copy KnowledgeRepository or AnnotationType toString() in clipboard

 */

public class Add extends AbstractHandler {

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		IStructuredSelection selection = (IStructuredSelection) HandlerUtil.getCurrentSelection(event);

//		System.out.println("Add: "+selection);

		add(selection);

		return null;

	}

	/**

	 * Copy.

	 *

	 * @param selection the selection

	 */

	public static void add(IStructuredSelection selection)

	{

		Object selectedItem = selection.getFirstElement();

		if (selectedItem instanceof SQLKnowledgeRepository) {

		} else if (selectedItem instanceof LocalKnowledgeRepository) {

			LocalKnowledgeRepository kr = ((LocalKnowledgeRepository)selectedItem);

			Shell shell = Display.getDefault().getActiveShell();

			InputDialog dialog = new InputDialog(shell, "Type name", "Please enter the new type name", "", null);

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

				String name = dialog.getValue();

				String id = AsciiUtils.buildId(name);

				//Generate an URL page 

				//String pathFile = KnowledgeRepositoryManager.generateLocalURLPage(kr.getName(), name, id);

				String pathFile = null; //@TODO build page for type or KR will be done in another version (after 0.7.8)

				//System.out.println("URL for new type : "+pathFile);

				AnnotationType at = kr.addType(name, id, pathFile);

				KRView.refresh();

				//kr.add(at);

			} else {

				System.out.println("Creation aborted.");

			}

		} else if (selectedItem instanceof AnnotationType) {

			AnnotationType t = ((AnnotationType)selectedItem);

			String krname = t.getKnowledgeRepository();

			KnowledgeRepository kr = KnowledgeRepositoryManager.getKnowledgeRepository(krname);

			if (kr instanceof LocalKnowledgeRepository) {

				LocalKnowledgeRepository lkr = ((LocalKnowledgeRepository)kr);

				System.out.println("Add a value...");

				Shell shell = Display.getDefault().getActiveShell();

				InputDialog dialog = new InputDialog(shell, "Value name", "Please enter the new value name", "", null);

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

					String name = dialog.getValue();

					String id = name;

					/*String baseid = AsciiUtils.buildId(name);

					String id = AsciiUtils.buildId(name);

					int c = 1;

					while (kr.getValue(t, id) != null) {

						id = baseid+"_"+(c++);

					}*/

					TypedValue val = lkr.addValue(name, id, t.getId());

					//t.addTypedValue(val);

					KnowledgeRepositoryManager.generateLocalURLPage(lkr.getName(), t.getName(), t.getId());

					KRView.refresh();

				}

			}

		} else if (selectedItem instanceof TypedValue) {

		}

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// 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.rcp.commands.krview;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.ui.handlers.HandlerUtil;

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

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

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

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

import org.txm.rcp.commands.OpenLocalizedWebPage;

/**

 * Shows a web page displaying informations about the current selection

 */

public class Informations extends AbstractHandler {

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		IStructuredSelection selection = (IStructuredSelection) HandlerUtil.getCurrentSelection(event);

//		System.out.println("Informations: "+selection);

		show(selection);

		return null;

	}

	/**

	 * Copy.

	 *

	 * @param selection the selection

	 */

	public static void show(IStructuredSelection selection)

	{

		Object selectedItem = selection.getFirstElement();

		String url = "";

		if (selectedItem instanceof SQLKnowledgeRepository) {

			url = ((SQLKnowledgeRepository)selectedItem).getURL();

		} else if (selectedItem instanceof LocalKnowledgeRepository) {

			LocalKnowledgeRepository kr = ((LocalKnowledgeRepository)selectedItem);

			url = ((LocalKnowledgeRepository)selectedItem).getURL();

		} else if (selectedItem instanceof AnnotationType) {

			url = ((AnnotationType)selectedItem).getURL();

		} else if (selectedItem instanceof TypedValue) {

			url = ""; // TODO: see how to retrieve its KR

		}

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

			OpenLocalizedWebPage.openfile(url);

		} else {

			System.out.println(selectedItem);

		}

	}

}

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

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.handlers.HandlerUtil;

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

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

// extends org.eclipse.ui.views.showView

public class OpenKRView extends AbstractHandler {

	public static final String ID = OpenKRView.class.getCanonicalName(); // org.txm.rcp.commands.krview.OpenKRView

	@Override

	public final Object execute(final ExecutionEvent event)

			throws ExecutionException {

		System.out.println("hello");

		IWorkbenchWindow window = HandlerUtil

				.getActiveWorkbenchWindowChecked(event);

		try {

			openView(window);

		} catch (PartInitException e) {

			throw new ExecutionException("Part could not be initialized", e); //$NON-NLS-1$

		}

		return null;

	}

	/**

	 * Opens the view with the given identifier.

	 * 

	 * @param viewId

	 *            The view to open; must not be <code>null</code>

	 * @throws PartInitException

	 *             If the part could not be initialized.

	 */

	public static void openView(final IWorkbenchWindow activeWorkbenchWindow, AnnotationType type)

					throws PartInitException {

		final IWorkbenchPage activePage = activeWorkbenchWindow.getActivePage();

		if (activePage == null) {

			return;

		}

		activePage.showView(KRView.ID);

		if (type != null) {

			KRView.showType(type);

		}

	}

	/**

	 * Opens the view with the given identifier.

	 * 

	 * @param viewId

	 *            The view to open; must not be <code>null</code>

	 * @throws PartInitException

	 *             If the part could not be initialized.

	 */

	public static void openView(final IWorkbenchWindow activeWorkbenchWindow)

					throws PartInitException {

		openView(activeWorkbenchWindow, null);

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// 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.rcp.commands.krview;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.ui.handlers.HandlerUtil;

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

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

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

import org.txm.rcp.utils.IOClipboard;

// TODO: Auto-generated Javadoc

/**

 * Copy KnowledgeRepository or AnnotationType toString() in clipboard

 */

public class Copy extends AbstractHandler {

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		IStructuredSelection selection = (IStructuredSelection) HandlerUtil.getCurrentSelection(event);

//		System.out.println("Copy: "+selection);

		copy(selection);

		return null;

	}

	/**

	 * Copy.

	 *

	 * @param selection the selection

	 */

	public static void copy(IStructuredSelection selection)

	{

		Object selectedItem = selection.getFirstElement();

		String text = null;

		if (selectedItem instanceof SQLKnowledgeRepository) {

			text = ((SQLKnowledgeRepository)selectedItem).toHumanString();

		} else if (selectedItem instanceof AnnotationType) {

			text = ((AnnotationType)selectedItem).toHumanString();

		} else if (selectedItem instanceof TypedValue) {

			text = ((TypedValue)selectedItem).toHumanString();

		}

		if (text != null) {

			IOClipboard.write(text);

		}

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// 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.rcp.commands.krview;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.swt.widgets.TreeItem;

import org.eclipse.ui.handlers.HandlerUtil;

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.views.knowledgerepositories.KRView;

// TODO: Auto-generated Javadoc

/**

 * Copy KnowledgeRepository or AnnotationType toString() in clipboard

 */

public class Delete extends AbstractHandler {

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		IStructuredSelection selection = (IStructuredSelection) HandlerUtil.getCurrentSelection(event);

//		System.out.println("Delete: "+selection);

		delete(selection);

		return null;

	}

	/**

	 * Copy.

	 *

	 * @param selection the selection

	 */

	public static void delete(IStructuredSelection selection)

	{

		Object selectedItem = selection.getFirstElement();

		if (selectedItem instanceof SQLKnowledgeRepository) {

		} else if (selectedItem instanceof LocalKnowledgeRepository) {

			LocalKnowledgeRepository kr = ((LocalKnowledgeRepository)selectedItem);

			System.out.println("Delete a LocalKnowledgeRepository...");

			//TODO: confirm message dialog to generate

			//KnowledgeRepositoryManager.deleteKnowledgeRepository(kr);

			//KRView.refresh();

		} else if (selectedItem instanceof AnnotationType) {

			final AnnotationType t = ((AnnotationType)selectedItem);

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

			if (kr instanceof LocalKnowledgeRepository) {

				final LocalKnowledgeRepository lkr = ((LocalKnowledgeRepository)kr);

				System.out.println("Delete an AnnotationType...");

				/*JobHandler job = new JobHandler("Deleting all annotations for type : "+t) {

					@Override

					protected IStatus run(IProgressMonitor monitor) {

						this.setCurrentMonitor(monitor);

						try {*/

							lkr.deleteType(t);

							//TODO: For each corpus, get AnnotationManager and deleteAnnotations

							//annotManager.deleteAnnotations(t, job);

						/*} catch(Exception e) {

							Log.severe("Error while deleting annotations "+e);

							Log.printStackTrace(e);

							return Status.CANCEL_STATUS;

						}

						return Status.OK_STATUS;

					}

				};

				job.schedule();*/

				//TODO: must delete corpus possible annotations

				KRView.refresh();

			}

		} else if (selectedItem instanceof TypedValue) {

			TypedValue v = (TypedValue) selectedItem;

			TreeViewer tree = KRView.getTree();

			if (tree != null) {

				TreeItem[] selItems = tree.getTree().getSelection();

				if (selItems.length == 0) return;

				TreeItem first = selItems[0];

				Object o = first.getData();

				if (o instanceof TypedValue) {

					TypedValue selectedTypedValue = (TypedValue)o;

					if (selectedTypedValue.getId().equals(v.getId())) {

						TreeItem parentTreeItem = first.getParentItem();

						Object o2 = parentTreeItem.getData();

						if (o2 instanceof AnnotationType) {

							AnnotationType t = (AnnotationType)o2;

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

							kr.deleteValue(v);

							tree.refresh();

						}

					}

				}

			}

		}

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// 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.rcp.preferences;

import org.eclipse.jface.preference.RadioGroupFieldEditor;

import org.eclipse.ui.IWorkbench;

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

import org.txm.rcp.IImageKeys;

import org.txm.rcp.Messages;

import org.txm.rcp.preferences.RCPPreferences;

import org.txm.rcp.preferences.RCPPreferencesPage;

import org.txm.rcp.preferences.TXMPreferencePage;

import org.txm.rcp.preferences.TXMPreferenceStore;

/**

 * This class represents a preference page that is contributed to the

 * Preferences dialog. By subclassing <samp>FieldEditorPreferencePage</samp>, we

 * can use the field support built into JFace that allows us to create a page

 * that is small and knows how to save, restore and apply itself.

 * <p>

 * This page is used to modif y preferences only. They are stored in the

 * preference store that belongs to the main plug-in class. That way,

 * preferences can be accessed directly via the preference store.

 */

public class AnnotationPreferencePage extends TXMPreferencePage {

	//private BooleanFieldEditor mode_expert;

	private RadioGroupFieldEditor mode_annotation;

	/**

	 * Instantiates a new cAH preference page.

	 */

	public AnnotationPreferencePage() {

		super();

	}

	/**

	 * Creates the field editors. Field editors are abstractions of the common

	 * GUI blocks needed to manipulate various types of preferences. Each field

	 * editor knows how to save and restore itself.

	 */

	@Override

	public void createFieldEditors() {

		/*BooleanFieldEditor mode_expert = new BooleanFieldEditor(MODE,

				Messages.AnnotationPreferences_0, getFieldEditorParent());	

		addField(mode_expert);*/

		String[][] labelAndValues = {

				{Messages.AnnotationPreferences_1, "simple"},

				{Messages.AnnotationPreferences_2, "advanced"}}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

		mode_annotation = new RadioGroupFieldEditor(AnnotationPreferences.ANNOTATION_MODE, Messages.AnnotationPreferences_0, 2, labelAndValues, getFieldEditorParent());

		addField(mode_annotation);

		//mode_annotation.setPreferenceStore(store);

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)

	 */

	@Override

	public void init(IWorkbench workbench) {

		this.setPreferenceStore(new TXMPreferenceStore(AnnotationPreferences.PREFERENCES_NODE));

		//this.setTitle("WordCloud");

		this.setImageDescriptor(IImageKeys.getImageDescriptor(IImageKeys.PENCIL));

	}

}

package org.txm.annotation.rcp.editors.imports.sections;

import java.util.List;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Text;

import org.eclipse.ui.forms.events.ExpansionAdapter;

import org.eclipse.ui.forms.events.ExpansionEvent;

import org.eclipse.ui.forms.widgets.FormToolkit;

import org.eclipse.ui.forms.widgets.ScrolledForm;

import org.eclipse.ui.forms.widgets.TableWrapData;

import org.eclipse.ui.forms.widgets.TableWrapLayout;

import org.txm.annotation.core.KRAnnotationEngine;

import org.txm.objects.BaseParameters;

import org.txm.rcp.editors.imports.sections.ImportEditorSection;

public class AnnotationSection extends ImportEditorSection {

	private static final int SECTION_SIZE = 1;

	public static final String DEFAULTNAMESUFFIX = "KR";

	Text nameText;

	public AnnotationSection(FormToolkit toolkit2, ScrolledForm form2, Composite parent, int style) {

		super(toolkit2, form2, parent, style);

		this.section.setText("Annotation");

		TableWrapLayout layout = new TableWrapLayout();

		layout.makeColumnsEqualWidth = true;

		this.section.setLayout(layout);

		this.section.setLayoutData(getSectionGridData(SECTION_SIZE));

		this.section.setEnabled(false);

		this.section.addExpansionListener(new ExpansionAdapter() {

			@Override

			public void expansionStateChanged(ExpansionEvent e) {form.layout(true);}

		});

		//filesection.setDescription("Select how to find source files");

		Composite sectionClient = toolkit.createComposite(this.section);

		TableWrapLayout slayout = new TableWrapLayout();

		slayout.makeColumnsEqualWidth = false;

		slayout.numColumns = 2;

		sectionClient.setLayout(slayout);

		this.section.setClient(sectionClient);

		Label l = toolkit.createLabel(sectionClient, "Knowledge repository name", SWT.WRAP);

		l.setLayoutData(new TableWrapData(TableWrapData.LEFT, TableWrapData.MIDDLE));

		nameText = new Text(sectionClient, SWT.BORDER);

	}

	@Override

	public void update(BaseParameters params) {

		if (this.section.isDisposed()) return;

		if (params == null) return;

		List<String> values = KRAnnotationEngine.getKnowledgeRepositoryNames(params);

		String value = params.getCorpusName()+DEFAULTNAMESUFFIX;

		if (values.size() > 0) {

			value = values.get(0);

		}

		nameText.setText(value);

	}

	@Override

	public boolean save(BaseParameters params) {

		if (!this.section.isDisposed()) {

			String value = nameText.getText();

			return true;

		}

		return false;

	}

	@Override

	public boolean checkFields() {

		return true;

	}

	@Override

	public int getSectionSize() {

		return SECTION_SIZE;

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// 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.rcp.views.knowledgerepositories;

import java.util.ArrayList;

import java.util.List;

import java.util.Arrays;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.jface.viewers.AbstractTreeViewer;

import org.eclipse.jface.viewers.DoubleClickEvent;

import org.eclipse.jface.viewers.IDoubleClickListener;

import org.eclipse.jface.viewers.ITreeContentProvider;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TreeSelection;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.jface.viewers.TreeViewerColumn;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.osgi.util.NLS;

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

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.contexts.IContextService;

import org.eclipse.ui.part.ViewPart;

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.krview.Copy;

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

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

import org.txm.rcp.IImageKeys;

import org.txm.rcp.Messages;

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

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

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

import org.txm.utils.logger.Log;

/**

 * Display the Knowledge repositories currently loaded

 * 

 * author mdecorde.

 */

public class KRView extends ViewPart {

	/** The empty list to filled the view at startup. */

	ArrayList<Object> empty = new ArrayList<Object>();

	/** The composites. */

	Control[] composites = new Control[3];

	/** The tv. */

	TreeViewer tv;