Laboratoire ICAR » Plateforme TXM

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

<?eclipse version="3.4"?>

<plugin>  

   <extension

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

               <command

            categoryId="org.txm.rcp.category.txm"

            defaultHandler="org.txm.rcp.commands.workspace.RecodeCorpus"

            id="org.txm.rcp.commands.workspace.RecodeCorpus"

            name="%command.name">

      </command>

            <command

            categoryId="org.txm.rcp.category.txm"

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

            id="org.txm.rcp.commands.annotation.SaveAnnotations"

            name="%command.name.0">

      </command>

            <command

            defaultHandler="org.txm.annotation.kr.rcp.commands.krview.OpenKRView"

            id="org.txm.rcp.commands.krview.OpenKRView"

            name="%command.name.1">

      </command>

      <command

            defaultHandler="org.txm.annotation.kr.rcp.commands.krview.Copy"

            id="org.txm.rcp.commands.krview.Copy"

            name="%command.name.2">

      </command>

      <command

            defaultHandler="org.txm.annotation.kr.rcp.commands.krview.Reload"

            id="org.txm.rcp.commands.krview.Reload"

            name="%command.name.3">

      </command>

      <command

            defaultHandler="org.txm.annotation.kr.rcp.commands.krview.Informations"

            id="org.txm.rcp.commands.krview.Informations"

            name="%command.name.4">

      </command>

      <command

            defaultHandler="org.txm.annotation.kr.rcp.commands.krview.Delete"

            id="org.txm.rcp.commands.krview.Delete"

            name="%command.name.5">

      </command>

      <command

            defaultHandler="org.txm.annotation.kr.rcp.commands.krview.Add"

            id="org.txm.rcp.commands.krview.Add"

            name="%command.name.6">

      </command>

      <command

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

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

            name="%command.name.7">

      </command>

      <command

            categoryId="org.txm.rcp.category.txm"

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

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

            name="%command.label.111">

      </command>

      <command

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

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

            name="%command.name.8">

      </command>

      <command

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

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

            name="%command.name.9">

      </command>

   </extension>

  <extension

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

     <page

           category="org.txm.annotation.rcp.preferences.AnnotationPreferencePage"

           class="org.txm.annotation.kr.rcp.preferences.KRAnnotationPreferencePage"

           id="org.txm.annotation.kr.rcp.preferences.KRAnnotationPreferencePage"

           name="%page.name.0">

     </page>

  </extension>

     <extension

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

      <view

            category="org.txm.rcp"

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

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

            name="%view.name"

            restorable="true">

      </view>

   </extension>

  <extension

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

      <key

            commandId="org.txm.rcp.commands.krview.Add"

            contextId="org.txm.rcp.annotation.krview"

            schemeId="org.txm.rcp.scheme"

            sequence="Ctrl+A">

      </key>

      <key

            commandId="org.txm.rcp.commands.krview.Reload"

            contextId="org.txm.rcp.annotation.krview"

            schemeId="org.txm.rcp.scheme"

            sequence="Ctrl+R">

      </key>

      <key

            commandId="org.txm.rcp.commands.krview.Informations"

            contextId="org.txm.rcp.annotation.krview"

            schemeId="org.txm.rcp.scheme"

            sequence="Ctrl+I">

      </key>

      <key

            commandId="org.txm.rcp.commands.krview.Copy"

            contextId="org.txm.rcp.annotation.krview"

            schemeId="org.txm.rcp.scheme"

            sequence="Ctrl+C">

      </key>

      <key

            commandId="org.txm.rcp.commands.krview.Delete"

            contextId="org.txm.rcp.annotation.krview"

            schemeId="org.txm.rcp.scheme"

            sequence="Ctrl+D">

      </key>

   </extension>

  <extension

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

     <menuContribution

           allPopups="false"

           locationURI="menu:menu.display.views?before=menu.display.views.separator">

           <command

                     commandId="org.txm.rcp.commands.krview.OpenKRView"

                     label="%command.label"

                     style="push">

               </command>

     </menuContribution>

     <menuContribution

            locationURI="popup:org.txm.annotation.kr.rcp.views.knowledgerepositories.KRView">

         <command

               commandId="org.txm.rcp.commands.krview.Copy"

               style="push"

               tooltip="%command.tooltip.89">

         </command>

         <command

               commandId="org.txm.rcp.commands.krview.Reload"

               style="push"

               tooltip="%command.tooltip.90">

            <visibleWhen

                  checkEnabled="false">

               <reference

                     definitionId="OneKRSelected">

               </reference>

            </visibleWhen>

         </command>

         <command

               commandId="org.txm.rcp.commands.krview.Informations"

               style="push"

               tooltip="%command.tooltip.93">

         </command>

         <command

               commandId="org.txm.rcp.commands.krview.Add"

               style="push"

               tooltip="%command.tooltip.94">

            <visibleWhen

                  checkEnabled="false">

               <or>

                  <reference

                        definitionId="OneLocalKRSelected">

                  </reference>

                  <reference

                        definitionId="OneAnnotationTypeSelected">

                  </reference>

               </or>

            </visibleWhen>

         </command>

         <command

               commandId="org.txm.rcp.commands.krview.Delete"

               style="push"

               tooltip="%command.tooltip.95">

            <visibleWhen

                  checkEnabled="false">

               <or>

                  <reference

                        definitionId="OneAnnotationTypeSelected">

                  </reference>

                  <reference

                        definitionId="OneTypedValueSelected">

                  </reference>

               </or>

            </visibleWhen>

         </command>

      </menuContribution>

     <menuContribution

           allPopups="false"

           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"

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

           <command

                 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>

     </menuContribution>

     <menuContribution

           allPopups="false"

           locationURI="menu:corporaview.menu.file.export?after=org.txm.rcp.views.corpora.CorporaView.annotation">

            <command

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

                  label="%command.label.0"

                  style="push">

               <visibleWhen

                     checkEnabled="false">

                  <reference

                        definitionId="OneMainCorpusSelected">

                  </reference>

               </visibleWhen>

            </command>

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

     <menuContribution

           allPopups="false"

           locationURI="menu:menu.corpus?after=menu.corpus.build">

           <command

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

                  icon="icons/functions/pencil_save.png"

                  label="%command.label.111"

                  style="push">

            </command>

     </menuContribution>

     <menuContribution

           allPopups="false"

           locationURI="popup:org.txm.rcp.views.corpora.CorporaView">

        <command

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

              icon="icons/functions/pencil_save.png"

              label="%command.label.111"

              style="push">

           <visibleWhen

                 checkEnabled="false">

              <reference

                    definitionId="CorpusNeedtoSaveAnnotation">

              </reference>

           </visibleWhen>

        </command>

     </menuContribution>

     <menuContribution

           allPopups="false"

           locationURI="toolbar:org.txm.rcp.toolbarcorpus?after=org.txm.rcp.toolbarcorpus.annotation">

        <command

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

              icon="icons/functions/pencil_save.png"

              label="CQP"

              mode="FORCE_TEXT"

              style="push"

              tooltip="CQP">

        </command>

     </menuContribution>

     <menuContribution

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

        <command

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

              label="%command.label.2"

              style="push">

           <visibleWhen

                 checkEnabled="false">

              <reference

                    definitionId="OneMainCorpusSelected">

              </reference>

           </visibleWhen>

        </command>

     </menuContribution>

  </extension>

  <extension

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

      <context

            description="%context.description"

            id="org.txm.rcp.annotation.krview"

            name="%context.name">

      </context>

   </extension>

  <extension

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

     <definition

                  id="OneKRSelected">

               <with

                     variable="selection">

                  <iterate

                        ifEmpty="false"

                        operator="and">

                     <instanceof

                           value="org.txm.annotation.KnowledgeRepository">

                     </instanceof>

                  </iterate>

               </with>

            </definition>

            <definition

                  id="OneLocalKRSelected">

               <with

                     variable="selection">

                  <iterate

                        ifEmpty="false"

                        operator="and">

                     <instanceof

                           value="org.txm.annotation.repository.LocalKnowledgeRepository">

                     </instanceof>

                  </iterate>

               </with>

            </definition>

                        <definition

                  id="OneAnnotationTypeSelected">

               <with

                     variable="selection">

                  <iterate

                        ifEmpty="false"

                        operator="and">

                     <instanceof

                           value="org.txm.annotation.repository.AnnotationType">

                     </instanceof>

                  </iterate>

               </with>

            </definition>

            <definition

                  id="OneTypedValueSelected">

               <with

                     variable="selection">

                  <iterate

                        ifEmpty="false"

                        operator="and">

                     <instanceof

                           value="org.txm.annotation.repository.TypedValue">

                     </instanceof>

                  </iterate>

               </with>

            </definition>

            <definition

                  id="CorpusNeedtoSaveAnnotation">

               <and>

                  <test

                        forcePluginActivation="true"

                        property="org.txm.rcp.testers.IsCorpusDirty">

                  </test>

               </and>

            </definition>

  </extension>

     <extension

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

      <propertyTester

            class="org.txm.rcp.testers.IsCorpusDirty"

            id="org.txm.rcp.testers.IsCorpusDirty"

            namespace="org.txm.rcp.testers"

            properties="IsCorpusDirty"

            type="java.lang.Object">

      </propertyTester>

   </extension>

  <extension

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

     <annotationtoolbar

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

           position="3">

     </annotationtoolbar>

     <annotationtoolbar

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

           position="1">

     </annotationtoolbar>

     <annotationtoolbar

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

           position="2">

     </annotationtoolbar>

  </extension>

</plugin>

eclipse.preferences.version=1

encoding//src/org/txm/annotation/kr/rcp/messages/messages.properties=UTF-8

encoding//src/org/txm/annotation/kr/rcp/messages/messages_fr.properties=UTF-8

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

<classpath>

	<classpathentry kind="con"

		path="org.eclipse.jdt.launching.JRE_CONTAINER" />

	<classpathentry kind="con"

		path="org.eclipse.pde.core.requiredPlugins">

		<accessrules>

			<accessrule kind="accessible" pattern="**" />

		</accessrules>

	</classpathentry>

	<classpathentry kind="src" path="src" />

	<classpathentry kind="output" path="bin" />

</classpath>

Manifest-Version: 1.0

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

 kr.rcp.commands.krview,org.txm.annotation.kr.rcp.concordance,org.txm.

 annotation.kr.rcp.editors.imports.sections,org.txm.annotation.kr.rcp.

 messages,org.txm.annotation.kr.rcp.preferences,org.txm.annotation.kr.

 rcp.views.knowledgerepositories

Bundle-SymbolicName: org.txm.annotation.kr.rcp;singleton:=true

Bundle-Version: 1.0.0.qualifier

Bundle-Name: %Bundle-Name

Require-Bundle: org.txm.annotation.kr.core;bundle-version="1.0.0";visi

 bility:=reexport,org.txm.annotation.rcp;bundle-version="1.0.0";visibi

 lity:=reexport

Bundle-ManifestVersion: 2

Bundle-RequiredExecutionEnvironment: JavaSE-16

Bundle-Vendor: Textometrie.org

Automatic-Module-Name: org.txm.annotation.kr.rcp

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

<projectDescription>

	<name>org.txm.annotation.kr.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.rcp.testers;

import java.util.List;

import org.eclipse.core.expressions.PropertyTester;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.PlatformUI;

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

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

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

import org.txm.core.results.TXMResult;

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

public class IsCorpusDirty extends PropertyTester {

	@Override

	public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {

		if (receiver instanceof List) {

			List list = (List) receiver;

			if (list.size() == 0) return true;

			receiver = list.get(0);

		}

		if (receiver instanceof TXMResult) {

			receiver = ((TXMResult) receiver).getFirstParent(MainCorpus.class);

		}

		if (receiver instanceof Line) {

			receiver = ((Line) receiver).getConcordance().getFirstParent(MainCorpus.class);

		}

		if (receiver instanceof MainCorpus) {

			return KRAnnotationEngine.needToSaveAnnotations(((MainCorpus) receiver));

		}

		IEditorPart e = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();

		if (e instanceof ConcordanceEditor) {

			KRAnnotationEngine.needToSaveAnnotations(((ConcordanceEditor) e).getCorpus().getMainCorpus());

		}

		return false;

	}

}

package org.txm.annotation.kr.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.osgi.util.NLS;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.handlers.HandlerUtil;

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

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

import org.txm.rcp.messages.TXMUIMessages;

import org.txm.rcp.utils.JobHandler;

import org.txm.rcp.utils.SWTEditorsUtils;

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

		try {

			JobHandler job = save(corpus);

			if (job == null) {

				return null;

			}

		}

		catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

			return null;

		}

		CorporaView.refresh();

		return corpus;

	}

	public static JobHandler save(final MainCorpus corpus) throws Exception {

		final AnnotationManager am = KRAnnotationEngine.getAnnotationManager(corpus);

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

		if (!KRAnnotationEngine.needToSaveAnnotations(corpus)) {

			return null;

		}

		JobHandler jobhandler = new JobHandler(NLS.bind("Saving annotations of {0}", corpus)) {

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				this.runInit(monitor);

				try {

					boolean rez = am.saveAnnotations(monitor);

					monitor.worked(30);

					if (rez) {

						Log.fine("Annotations are saved in XML-TXM files. Updating corpus indexes and editions");

						// close all opened editors of all children corpus

						SWTEditorsUtils.closeEditors(corpus.getProject(), true);

					}

					else {

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

					}

				}

				catch (Exception e) {

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

					Log.printStackTrace(e);

					return Status.CANCEL_STATUS;

				} catch(ThreadDeath ex) {

					Log.info(TXMUIMessages.executionCanceled);

					return Status.CANCEL_STATUS;

				}

				return Status.OK_STATUS;

			}

		};

		jobhandler.startJob(true);

		jobhandler.join();

		return jobhandler;

	}

}

package org.txm.annotation.kr.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.osgi.util.NLS;

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.kr.core.conversion.CorpusRuledConvertion;

import org.txm.annotation.kr.rcp.messages.KRAnnotationUIMessages;

import org.txm.core.preferences.TBXPreferences;

import org.txm.objects.Project;

import org.txm.rcp.commands.CloseEditorsUsing;

import org.txm.rcp.handlers.scripts.ExecuteImportScript;

import org.txm.rcp.messages.TXMUIMessages;

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 = "how to manage failed conversion", 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) {

						this.runInit(monitor);

						try {

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

						} catch (Exception e) {

							Log.warning(NLS.bind("Fail to convert properties of the {0} corpus.", corpus));

							e.printStackTrace();

							return Status.CANCEL_STATUS;

						} catch(ThreadDeath ex) {

							Log.info(TXMUIMessages.executionCanceled);

							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 {

		Project project = corpus.getProject();

		if (!"xtz".equals(project.getImportModuleName())) {

			Log.warning(NLS.bind("The {0} corpus was not imported with the XTZ import module", corpus));

			return null;

		}

		Property p1 = corpus.getProperty(oldType);

		if (p1 == null) {

			Log.warning(NLS.bind("The {0} corpus has no {1} property.", corpus, oldType));

			return null;

		}

		Log.info(NLS.bind("Recoding the {0} corpus properties: {1}.", corpus, oldType+" -> "+newType));

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

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

		// apply conversion file

		if (!crc.process(corpus)) {

			Log.warning(NLS.bind("Failed to edit XML-TXM of the {0} corpus.", corpus));

			return null;

		}

		monitor.worked(1);

		// update corpus indexes and edition

		// String txmhome = Toolbox.getTxmHomePath();

		project.setDoMultiThread(false); // too soon

		project.setDoUpdate(true, false);

		// monitor.setTaskName("Updating corpus");

		// File scriptDir = new File(txmhome, "scripts/groovy/user/org/txm/scripts/importer/xtz");

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

		Log.info(NLS.bind(KRAnnotationUIMessages.updatingTheP0Corpus, corpus));

		JobHandler ret = ExecuteImportScript.executeScript(project);

		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 {

		Log.info(NLS.bind("Create CorpusRuledConvertion with the {0} conversion file.", conversionFile));

		// apply conversion file

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

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

	}

}

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

import java.util.ArrayList;

import java.util.Collections;

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.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.jface.window.Window;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.handlers.HandlerUtil;

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

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

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

import org.txm.core.results.TXMResult;

import org.txm.objects.Workspace;

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

import org.txm.rcp.messages.TXMUIMessages;

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

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 SaveAnnotationsAndUpdateCorpus extends AbstractHandler {

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

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		ISelection sel = HandlerUtil.getCurrentSelection(event);

//		if (!(sel instanceof IStructuredSelection)) {

//			Log.info("No available selection to target the corpus annotations to save");	

//			return null;

//		}

		IStructuredSelection selection = (IStructuredSelection) sel;

		List<MainCorpus> corpora = Workspace.getInstance().getDeepChildren(MainCorpus.class);

		Collections.sort(corpora);

		ArrayList<MainCorpus> corpusWithAnnotationsToSave = new ArrayList<>();

		for (MainCorpus corpus : corpora) {

			if (KRAnnotationEngine.needToSaveAnnotations(corpus)) {

				corpusWithAnnotationsToSave.add(corpus);

			}

		}

//		if (HandlerUtil.getActiveEditor(event) instanceof ConcordanceEditor) {

//			corpus = ((ConcordanceEditor) HandlerUtil.getActiveEditor(event)).getCorpus().getMainCorpus();

//		} else {

//			Object s = selection.getFirstElement();

//			if (s == null) {

//				Log.info("No available selection to target the corpus annotations to save");

//				return null;

//			} else if ((s instanceof MainCorpus)) {

//				corpus = (MainCorpus) s;

//			} else if (s instanceof TXMResult) {

//				corpus = ((TXMResult) s).getFirstParent(MainCorpus.class);

//			} else {

//				Log.info("No available selection to target the corpus annotations to save");

//				return null;

//			}

//		}

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

			Log.info(NLS.bind("No CQP annotations found to save in the corpora: {0}", corpora));

			return null;

		}

		try {

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

			final Boolean[] doit = new Boolean[1];

			doit[0] = true;

			final MainCorpus[] corpus = new MainCorpus[1];

			final Boolean[] doupdateedition = new Boolean[1];

			doupdateedition[0] = KRAnnotationPreferences.getInstance().getBoolean(KRAnnotationPreferences.UPDATE_EDITION);

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

				@Override

				public void run() {

					UpdateCorpusDialog dialog = new UpdateCorpusDialog(Display.getDefault().getActiveShell());

					dialog.setTitle("Before saving annotations...");

					dialog.setMessages("Save Annotations and update the corpus.", dialog.getBottomMessage());

					dialog.setDoForceUpdate(false);

					dialog.setDoUpdateEdition(KRAnnotationPreferences.getInstance().getBoolean(KRAnnotationPreferences.UPDATE_EDITION));

					if (selection.getFirstElement() != null && selection.getFirstElement() instanceof MainCorpus) {

						dialog.setCorpusToUpdate((MainCorpus) selection.getFirstElement());

					}

					dialog.setCorporaToUpdate(corpusWithAnnotationsToSave);

					doit[0] = dialog.open() == Window.OK;

					doupdateedition[0] = dialog.getDoUpdateEdition();

					corpus[0] = dialog.getCorpustoUpdate();

				}

			});

			if (doit[0] == false) {

				return null;

			}

			final MainCorpus fcorpus = corpus[0];

			Log.info(NLS.bind("Saving {0} annotations...", fcorpus.getName()));

			JobHandler job = SaveAnnotations.save(fcorpus);

			if (job == null) {

				return null;

			}

			if (job.getState() == Status.OK_STATUS.getCode()) {

				if (KRAnnotationPreferences.getInstance().getBoolean(KRAnnotationPreferences.UPDATE)) {

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

						@Override

						protected IStatus run(IProgressMonitor monitor) {

							this.runInit(monitor);

							try {

								monitor.setTaskName("Updating corpus");

								if (fcorpus != null && UpdateCorpus.update(fcorpus, false, doupdateedition[0]) != null) {

									monitor.worked(50);

									this.syncExec(new Runnable() {

										@Override

										public void run() {

											CorporaView.refreshObject(fcorpus);

										}

									});

									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;

								}

							} catch(ThreadDeath ex) {

								Log.info(TXMUIMessages.executionCanceled);

								return Status.CANCEL_STATUS;

							}

						}

					};

					job2.schedule();

				} else {

					Log.warning("CQP indexes not updated. Only the XML-TXM files have been updated. Call Update corpus later to access the annotations");

				}

			}

			CorporaView.refresh();

			return fcorpus;

		}

		catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

			return null;

		}

	}

}

package org.txm.annotation.kr.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.osgi.util.NLS;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.handlers.HandlerUtil;

import org.osgi.service.prefs.BackingStoreException;

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

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

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

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

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

import org.txm.utils.logger.Log;

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;

			try {

				kr = KRAnnotationEngine.getKnowledgeRepository(corpus, kr_name);

				if (kr == null) {

					Log.warning(NLS.bind("Warning ''{0}'' KR is null. Please check KR configuration.", kr_name));

					continue;

				}

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

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

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

					Log.info(NLS.bind("Asking credentials for {0} KR login.", kr_name));

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

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

						Log.info("Temporary save login+password");

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

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

					} else {

						Log.info(NLS.bind("Cancelling login for {0} KR.", kr_name));

						continue; // ignoring

					}

				}

				if (!kr.checkConnection()) {

					Log.warning(NLS.bind("Error during connection to the ''{0}'' KR. Please check login, password and Internet connection.", kr_name));

				} else {

					ret.add(kr);

				}

			} catch (BackingStoreException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

		return ret;

	}

}

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

	}

}

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

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;

// 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)) {

			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.zip");

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

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

			StatusLine.setMessage(TXMUIMessages.exportingAnnotations);

			String filepath = dialog.getFilterPath();

			String filename = dialog.getFileName();

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

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

			try {

				exportAnnotations(corpus, resultZipFile);

			} catch (Exception e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

				return null;

			}

		}

		return corpus;

	}

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

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

						Log.warning("Error while saving stand-off 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.krview;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;