Laboratoire ICAR » Plateforme TXM

				concordance.getCorpus().getLanguage()); //$NON-NLS-1$

				concordance.getCorpus().getLanguage()); //$NON-NLS-1$

				concordance.getCorpus().getLanguage()); 

				concordance.getCorpus().getLanguage()); //$NON-NLS-1$

				concordance.getCorpus().getLanguage()); //$NON-NLS-1$

				concordance.getCorpus().getLanguage()); //$NON-NLS-1$

					.getLanguage()), result);

      id="org.txm.annotation.urs.feature"

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

	<name>org.txm.annotation.urs.feature</name>

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

import org.txm.annotation.urs.preferences.AnalecPreferencePage;

import org.txm.annotation.urs.preferences.AnalecPreferences;

package org.txm.annotation.urs.imports;

import java.io.File;

import java.io.FilenameFilter;

import java.io.IOException;

import java.io.InputStream;

import java.net.MalformedURLException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import javax.xml.stream.XMLInputFactory;

import javax.xml.stream.XMLStreamConstants;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamReader;

import org.apache.commons.lang.StringUtils;

import org.eclipse.core.runtime.IProgressMonitor;

import org.txm.Toolbox;

import org.txm.importer.PersonalNamespaceContext;

import org.txm.searchengine.cqp.AbstractCqiClient;

import org.txm.searchengine.cqp.CQPSearchEngine;

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

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

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

import org.txm.utils.logger.Log;

import visuAnalec.donnees.Corpus;

import visuAnalec.elements.Relation;

import visuAnalec.elements.Schema;

import visuAnalec.elements.Unite;

import visuAnalec.fichiers.FichiersGlozz;

import visuAnalec.vue.Vue;

public class AnalecAnnotationsImporter {

	protected MainCorpus mainCorpus;

	protected Corpus analecCorpus;

	protected File annotationsDirectory;

	protected Vue analecVue;

	protected IProgressMonitor monitor;

	protected XMLInputFactory factory;

	protected File aamFile;

	protected static PersonalNamespaceContext Nscontext = new PersonalNamespaceContext();

	public AnalecAnnotationsImporter(IProgressMonitor monitor, File outputDirectory, File aamFile, MainCorpus mainCorpus, Corpus analecCorpus, Vue analecVue) {

		this.annotationsDirectory = outputDirectory;

		this.aamFile = aamFile;

		this.mainCorpus = mainCorpus;

		this.analecCorpus = analecCorpus;

		this.analecVue = analecVue;

		this.monitor = monitor;

	}

	public boolean process() throws Exception {

		if (!annotationsDirectory.exists()) {

			System.out.println("Error: annotationsDirectory does not exist: "+annotationsDirectory.getAbsolutePath());

			return false;

		}

		if (!annotationsDirectory.isDirectory()) {

			System.out.println("Error: annotationsDirectory is not a directory: "+annotationsDirectory.getAbsolutePath());

			return false;

		}

		if (!aamFile.exists()) {

			System.out.println("Error: aamFile does not exist: "+aamFile.getAbsolutePath());

			return false;

		}

		if (!FichiersGlozz.importerModeleGlozz(analecCorpus, aamFile)) {

			System.out.println("Error while importing Glozz model: "+aamFile);

			return false;

		}

		File[] ursFiles = annotationsDirectory.listFiles(new FilenameFilter() {

			@Override

			public boolean accept(File dir, String name) {

				return name.matches(".+-urs\\.xml");

			}

		});

		if (ursFiles == null) {

			System.out.println("No XML files found in "+annotationsDirectory);

			return false;

		}

		if (ursFiles.length == 0) {

			System.out.println("No XML files found in "+annotationsDirectory);

			return false;

		}

		Arrays.sort(ursFiles);

		factory = XMLInputFactory.newInstance();

		List<String> cqpTextIds = mainCorpus.getProject().getTextsID();

		List<Integer> all_result_summary = Arrays.asList(0,0,0,0,0,0,0,0);

		if (monitor != null) monitor.subTask("Processing "+ursFiles.length+" texts...");

		for (File xmlTXMFile : ursFiles) {

			String textid = xmlTXMFile.getName().substring(0, xmlTXMFile.getName().length() - 8);

			System.out.println("Processing text: "+textid);

			if (cqpTextIds.contains(textid)) {

				if (monitor != null) monitor.subTask("Processing "+textid+" text...");

				// N unit, N unit error, N unit no match error, N unit too much match error, N Relation, N Relation error, N Schema, N Schema error

				List<Integer> result_summary = processText(textid, xmlTXMFile);

				System.out.println(textid+" import report: ");

				System.out.println(" N Units added: "+result_summary.get(0));

				System.out.println(" N Units error: "+result_summary.get(1));

				System.out.println(" N Units no match error: "+result_summary.get(2));

				System.out.println(" N Units too much match error: "+result_summary.get(3));

				System.out.println(" N Relations added: "+result_summary.get(4));

				System.out.println(" N Relations error: "+result_summary.get(5));

				System.out.println(" N Schemas added: "+result_summary.get(6));

				System.out.println(" N Schemas error: "+result_summary.get(7));

				for (int i = 0 ; i < all_result_summary.size() ; i++) all_result_summary.set(i, all_result_summary.get(i)+result_summary.get(i));

			} else {

				System.out.println("Warning: cannot found text with ID="+textid+" in current CQP corpus.");

			}

		}

		System.out.println("Final import report: ");

		System.out.println(" N Units added: "+all_result_summary.get(0));

		System.out.println(" N Units error: "+all_result_summary.get(1));

		System.out.println(" N Units no match error: "+all_result_summary.get(2));

		System.out.println(" N Units too much match error: "+all_result_summary.get(3));

		System.out.println(" N Relations added: "+all_result_summary.get(4));

		System.out.println(" N Relations error: "+all_result_summary.get(5));

		System.out.println(" N Schemas added: "+all_result_summary.get(6));

		System.out.println(" N Schemas error: "+all_result_summary.get(7));

		return true;

	}

	private List<Integer> processText(String textid, File xmlTXMFile) throws Exception {

		AbstractCqiClient CQI = CQPSearchEngine.getCqiClient();

		// N unit, N unit error, N unit no match error, N unit too much match error, N Relation, N Relation error, N Schema, N Schema error

		int nUnitsAdded = 0;

		int nUnitsError = 0;

		int nUnitsNoMatchError = 0;

		int nUnitsTooMuchMatchError = 0;

		int nRelationsAdded = 0;

		int nRelationsError = 0;

		int nSchemaAdded = 0;

		int nSchemaError = 0;

		unites.clear();

		relations.clear();

		schemas.clear();

		elementProperties.clear();

		if (!parseXMLTXMFile(xmlTXMFile)) return null;

//		if (unites.size() > 0) System.out.println(unites);

//		if (relations.size() > 0) System.out.println(relations);

//		if (schemas.size() > 0) System.out.println(schemas);

//		if (elementProperties.size() > 0) System.out.println(elementProperties);

//		for (String u : unites.keySet()) if (!elementProperties.containsKey(u+"-fs")) System.out.println("MISSIGN ELEM PROPERTIES: "+u);

//		for (String u : relations.keySet()) if (!elementProperties.containsKey(u+"-fs")) System.out.println("MISSIGN ELEM PROPERTIES: "+u);

//		for (String u : schemas.keySet()) if (!elementProperties.containsKey(u+"-fs")) System.out.println("MISSIGN ELEM PROPERTIES: "+u);

		for (String id : unites.keySet()) {

			String ana = unites.get(id)[0];

			String type = unites.get(id)[1];

			String deb = unites.get(id)[2];

			String fin = unites.get(id)[3];

			if (elementProperties.containsKey(ana)) {

				try {

					CQLQuery query = new CQLQuery("[_.text_id=\""+textid+"\" & id=\""+deb+"|"+fin+"\"]");

					QueryResult result = mainCorpus.query(query, "TMP", true);

					int[] starts = result.getStarts();

					result.drop();

					if (starts.length == 1) {

						//System.out.println("create unite: "+type+" ["+deb+", "+fin+"]");

						Unite unite = analecCorpus.addUniteSaisie(type, starts[0], starts[0]);

						HashMap<String, String> props = elementProperties.get(ana);

						for (String prop : props.keySet()) {

							unite.putProp(prop, props.get(prop));

						}

						unitesRef.put(id, unite);

						nUnitsAdded++;

					} else if (starts.length == 2) {

						Unite unite = analecCorpus.addUniteSaisie(type, starts[0], starts[1]);

						//System.out.println("create unite: "+type+" ["+deb+", "+fin+"]");

						HashMap<String, String> props = elementProperties.get(ana);

						for (String prop : props.keySet()) {

							unite.putProp(prop, props.get(prop));

						}

						unitesRef.put(id, unite);

						nUnitsAdded++;

					} else {

						nUnitsError++;

						if (starts.length == 0) {

							System.out.println("WARNING: no position found for query "+query+".");

							nUnitsNoMatchError++;

						} else {

							System.out.println("WARNING: too many positions found for query "+query+" -> "+Arrays.toString(starts));

							nUnitsTooMuchMatchError++;

						}

					}

				} catch(Exception e) {

					System.out.println("Error while getting word positions of id="+deb+" and id="+fin+": "+e.getLocalizedMessage());

					Log.printStackTrace(e);

				}

			} else {

				System.out.println("Warning no properties found for element id="+id+" and ana="+ana);

			}

		}

		for (String id : relations.keySet()) {

			String ana = relations.get(id)[0];

			String type = relations.get(id)[1];

			String target = relations.get(id)[2];

			if (elementProperties.containsKey(ana)) {

				String[] wordsref = target.split(" ");

				String[] wordsid = new String[wordsref.length];

				for (int i = 0 ; i < wordsref.length ; i++) wordsid[i] = wordsref[i].substring(1);

				try {

					Unite elt1 = unitesRef.get(wordsid[0]);

					Unite elt2 = unitesRef.get(wordsid[1]);

					if (elt1 != null && elt2 != null) {

						//System.out.println("create relation: "+type+" ["+deb+", "+fin+"]");

						Relation relation = analecCorpus.addRelationSaisie(type, elt1, elt2);

						HashMap<String, String> props = elementProperties.get(ana);

						for (String prop : props.keySet()) {

							relation.putProp(prop, props.get(prop));

						}

						nRelationsAdded++;

					} else {

						System.out.println("ERROR: relation element not found "+Arrays.toString(wordsref));

						nRelationsError++;

					}

				} catch(Exception e) {

				}

			} else {

				System.out.println("Warning no properties found for element id="+id);

			}

		}

		for (String id : schemas.keySet()) {

			String ana = schemas.get(id)[0];

			String type = schemas.get(id)[1];

			String target = schemas.get(id)[2];

			if (elementProperties.containsKey(ana)) {

				String[] unitsref = target.split(" ");

				try {

					//System.out.println("create relation: "+type+" ["+deb+", "+fin+"]");

					Schema schema = new Schema(type);

					for (String unitid : unitsref) {

						unitid = unitid.substring(1); // remove '#'

						if (unitesRef.containsKey(unitid)) {

							Unite unite = unitesRef.get(unitid);

							schema.ajouter(unite);

						} else {

							System.out.println("Warning: missing unit id: "+unitid);

							nSchemaError++;

						}

					}

					analecCorpus.addSchemaLu(schema);

					HashMap<String, String> props = elementProperties.get(ana);

					for (String prop : props.keySet()) {

						schema.putProp(prop, props.get(prop));

					}

					nSchemaAdded++;

				} catch(Exception e) {

					System.out.println("Error while creating schema with id="+id);

				}

			} else {

				System.out.println("Warning no properties found for element id="+id);

			}

		}

		return Arrays.asList(nUnitsAdded, nUnitsError, nUnitsNoMatchError, nUnitsTooMuchMatchError,

		nRelationsAdded, nRelationsError,

		nSchemaAdded, nSchemaError);

	}

	private boolean parseXMLTXMFile(File xmlTXMFile) throws XMLStreamException, MalformedURLException, IOException {

		InputStream inputData = xmlTXMFile.toURI().toURL().openStream();

		factory = XMLInputFactory.newInstance();

		XMLStreamReader parser = factory.createXMLStreamReader(inputData);

		String currentType = null;

		String currentN = null;

		String currentAna = null;

		String currentName = null;

		String currentPropValue = null;

		int processMode = 0; // 0 nothing, 1 elements 2 properties

		if (!goToStandOff(parser)) {

			System.out.println("Error: cannot find the 'standOff' element in "+xmlTXMFile);

			return false;

		}

		String localname = null;

		for (int event = parser.next(); event != XMLStreamConstants.END_DOCUMENT; event = parser.next()) {

			switch (event) {

			case XMLStreamConstants.START_ELEMENT:

				localname = parser.getLocalName();

				if (localname.equals("annotationGrp")) {

					currentType = parser.getAttributeValue(null, "type");

					currentN = parser.getAttributeValue(null, "subtype");

					if (currentType != null && currentN != null) {

						processMode = 1;

					} else {

						System.out.println("Warning found "+localname+" without 'type' and 'n' attribute");

						processMode = 0;

					}

				} else if (localname.equals("div")) {

					String type = parser.getAttributeValue(null, "type");

					if (type == null) type = "";

					if (type.endsWith("-fs"))

					processMode = 2;

				} 

				if (processMode == 1) {

					if (localname.equals("span") || localname.equals("link")) {

						String id = parser.getAttributeValue(null, "id");

						String ana = parser.getAttributeValue(null, "ana");

						//System.out.println("SPAN id="+id +" ana="+ana+" currentType="+currentType+" currentN="+currentN);

						if ("Unit".equals(currentType)) {

							String from = parser.getAttributeValue(null, "from");

							String to = parser.getAttributeValue(null, "to");

							registerUnite(id, ana, currentN, from, to);

						} else if ("Relation".equals(currentType)) {

							String target = parser.getAttributeValue(null, "target");

							registerRelation(id, ana, currentN, target);

						} else if ("Schema".equals(currentType)) {

							String target = parser.getAttributeValue(null, "target");

							registerSchema(id, ana, currentN, target);

						}

					}

				} else if (processMode == 2) {

					if (localname.equals("fs")) {

						currentAna = parser.getAttributeValue(null, "id");

						if (elementProperties.get(currentAna) != null) System.out.println("WARNING: duplicated element properties: "+currentAna);

						elementProperties.put(currentAna, new HashMap<String, String>());

					} else if (localname.equals("f")) {

						currentName= parser.getAttributeValue(null, "name");

						currentPropValue = "";

					}

				} else {

					// nothing to do

				} 

				break;		

			case XMLStreamConstants.CHARACTERS:

				if (processMode == 2 && currentAna != null && currentName != null) {

					currentPropValue += parser.getText();

				}

				break;

			case XMLStreamConstants.END_ELEMENT:

				localname = parser.getLocalName();

				if (localname.equals("standOff")) { // stop all

					parser.close();

					inputData.close();

					return true;

				} else if (processMode == 1 && localname.equals("annotationGrp")) { // stop all

					currentType = null;

					currentN = null;

					processMode = 0;

				} else if (processMode == 2 && localname.equals("div")) {

					processMode = 0;

				}

				if (processMode == 1) {

				} else if (processMode == 2) {

					if (localname.equals("fs")) {

						currentAna = null;

					} else if (localname.equals("f")) {

						if (currentName != null && currentAna != null) {

							elementProperties.get(currentAna).put(currentName, currentPropValue);

						}

						currentName = null;

					}

				} else {

					// nothing to do

				}

				break;

			case XMLStreamConstants.END_DOCUMENT:

				parser.close();

				inputData.close();

				return false;

			}

		}

		parser.close();

		inputData.close();

		return false; // standOff not found

	}

	HashMap<String, HashMap<String, String>> elementProperties = new HashMap<String, HashMap<String, String>>();

	HashMap<String, String[]> unites = new HashMap<String, String[]>(); // id -> {ana, type, from, to}

	HashMap<String, Unite> unitesRef = new HashMap<String, Unite>(); // id -> Unite

	private void registerUnite(String id, String ana, String type, String from, String to) {

		String[] data = {ana.substring(1), type, from.substring(5), to.substring(5)};

		if (unites.containsKey(id)) {

			System.out.println("Warning: duplicated Unite id: "+id);

		} else {

			unites.put(id, data);

		}

	}

	HashMap<String, String[]> relations = new HashMap<String, String[]>(); // id -> {ana, type, target}

	private void registerRelation(String id, String ana, String type, String target) {

		String[] data = {ana.substring(1), type, target};

		if (relations.containsKey(id)) {

			System.out.println("Warning: duplicated Relation id: "+id);

		} else {

			relations.put(id, data);

		}

	}

	HashMap<String, String[]> schemas = new HashMap<String, String[]>(); // id -> {ana, type, target}

	private void registerSchema(String id, String ana, String type, String target) {

		String[] data = {ana.substring(1), type, target};

		//System.out.println("R schema: "+id+" : "+Arrays.toString(data));

		if (schemas.containsKey(id)) {

			System.out.println("Warning: duplicated Schema id: "+id);

		} else {

			schemas.put(id, data);

		}

	}

	private boolean goToStandOff(XMLStreamReader parser) throws XMLStreamException {

		for (int event = parser.next(); event != XMLStreamConstants.END_DOCUMENT; event = parser.next()) {

			switch (event) {

			case XMLStreamConstants.START_ELEMENT:

				String localname = parser.getLocalName();

				if (localname.equals("standOff")) return true;

				break;		

			}

		}

		return false;

	}

}

package org.txm.annotation.urs.imports;

import java.io.File;

import java.io.FilenameFilter;

import java.util.HashMap;

import javax.xml.stream.XMLInputFactory;

import org.eclipse.core.runtime.IProgressMonitor;

import org.txm.Toolbox;

import org.txm.importer.PersonalNamespaceContext;

import org.txm.searchengine.cqp.AbstractCqiClient;

import org.txm.searchengine.cqp.CQPSearchEngine;

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

import org.txm.utils.xml.DomUtils;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

import visuAnalec.donnees.Corpus;

import visuAnalec.vue.Vue;

public class DOMAnalecAnnotationsImporter {

	MainCorpus mainCorpus;

	Corpus analecCorpus;

	File annotationsDirectory;

	private Vue analecVue;

	private IProgressMonitor monitor;

	private XMLInputFactory factory;

	protected static PersonalNamespaceContext Nscontext = new PersonalNamespaceContext();

	public DOMAnalecAnnotationsImporter(IProgressMonitor monitor, File outputDirectory, MainCorpus mainCorpus, Corpus analecCorpus, Vue analecVue) {

		this.annotationsDirectory = outputDirectory;

		this.mainCorpus = mainCorpus;

		this.analecCorpus = analecCorpus;

		this.analecVue = analecVue;

		this.monitor = monitor;

	}

	public boolean process() throws Exception {

		if (!annotationsDirectory.exists()) return false;

		if (!annotationsDirectory.isDirectory()) return false;

		File[] ursFiles = annotationsDirectory.listFiles(new FilenameFilter() {

			@Override

			public boolean accept(File dir, String name) {

				return name.matches(".+-urs\\.xml");

			}

		});

		if (ursFiles == null) {

			System.out.println("No XML files found in "+annotationsDirectory);

			return false;

		}

		if (ursFiles.length == 0) {

			System.out.println("No XML files found in "+annotationsDirectory);

			return false;

		}

		factory = XMLInputFactory.newInstance();

		for (File xmlAnalec : ursFiles) {

			String textid = xmlAnalec.getName().substring(0, xmlAnalec.getName().length() - 8);

			System.out.println("Processing text: "+textid);

			processText(textid, xmlAnalec);

		}

		return true;

	}

	private void processText(String textid, File xmlAnalec) throws Exception {

		AbstractCqiClient CQI = CQPSearchEngine.getCqiClient();

		HashMap<String, HashMap<String, String>> elementProperties = new HashMap<String, HashMap<String, String>>();

		Document doc = DomUtils.load(xmlAnalec);

		NodeList textElements = doc.getElementsByTagName("stdf");

		for (int iText = 0 ; iText < textElements.getLength() ; ) {

			Element text = (Element)textElements.item(iText);

			NodeList backElements = text.getElementsByTagName("annotations");

			for (int iBack = 0 ; iBack < backElements.getLength() ; ) {

				Element back = (Element)backElements.item(iBack);

				NodeList divElements = text.getElementsByTagName("div");

				for (int ifvLib = 0 ; ifvLib < divElements.getLength() ; ifvLib++) {

					Element divElement = (Element)divElements.item(ifvLib);

					String n = divElement.getAttribute("type");

					if (n == null) n = "";

					if (n.endsWith("-fs")) {

						getElementPropertiesFromFvLibElement(elementProperties, divElement);

					}

				}

				NodeList children = back.getElementsByTagName("spanGrp");

				for (int iChild = 0 ; iChild < children.getLength() ; iChild++) {

					Element spanGrpElement = (Element)children.item(iChild);

					String type = spanGrpElement.getAttribute("type");

					String n = spanGrpElement.getAttribute("subtype");

					if (type.equals("Unit")) {

						getUnitesFromSpanGrp(spanGrpElement, n);

					}

				}

				children = back.getElementsByTagName("joinGrp");

				for (int iChild = 0 ; iChild < children.getLength() ; iChild++) {

					Element joinGrpElement = (Element)children.item(iChild);

					String type = joinGrpElement.getAttribute("type");

					String n = joinGrpElement.getAttribute("subtype");

					if (type.equals("Relation")) {

						getRelationsFromJoinGrp(joinGrpElement, n);

					}

				}

				children = back.getElementsByTagName("joinGrp");

				for (int iChild = 0 ; iChild < children.getLength() ; iChild++) {

					Element joinGrpElement = (Element)children.item(iChild);

					String type = joinGrpElement.getAttribute("type");

					String n = joinGrpElement.getAttribute("subtype");

					if (type.equals("Schema")) {

						getSchemasFromJoinGrp(joinGrpElement, n);

					}

				}

				break; // stop at first back

			}

			break; // stop at first text

		}

	}

	private void getSchemasFromJoinGrp(Element joinGrpElement, String n) {

		NodeList children = joinGrpElement.getElementsByTagName("join");

		for (int iChild = 0 ; iChild < children.getLength() ; iChild++) {

			Element joinElement = (Element)children.item(iChild);

			String id = joinElement.getAttribute("id");

			String target = joinElement.getAttribute("target");

			String ana = joinElement.getAttribute("ana");

		}

	}

	private void getRelationsFromJoinGrp(Element joinGrpElement, String n) {

		// TODO Auto-generated method stub

	}

	private void getUnitesFromSpanGrp(Element spanGrpElement, String n) {

		// TODO Auto-generated method stub

	}

	private void getElementPropertiesFromFvLibElement(HashMap<String, HashMap<String, String>> elementProperties, Element divElement) {

		NodeList fsElements = divElement.getElementsByTagName("fs");

		for (int iChild = 0 ; iChild < fsElements.getLength() ; iChild++) {

			Element fsElement = (Element)fsElements.item(iChild);

			String id = fsElement.getAttribute("id");

			if (elementProperties.containsKey(id)) {

				System.out.println("Warning: duplicated fsElement id: "+id);

			} else {

				HashMap<String, String> properties = new HashMap<String, String>();

				elementProperties.put(id, properties);

				NodeList fElements = fsElement.getElementsByTagName("f");

				for (int iChild2 = 0 ; iChild2 < fElements.getLength() ; iChild2++) {

					Element fElement = (Element)fElements.item(iChild2);

					String name = fElement.getAttribute("name");

					if (properties.containsKey(name)) {

						System.out.println("Warning: duplicated fElement name: "+name+" in "+id+" fsElement.");

					} else {

						properties.put(name, fElement.getTextContent().trim());

					}

				}

			}

		}

	}

}

package org.txm.annotation.urs.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.kohsuke.args4j.Option;

import org.txm.annotation.urs.AnalecCorpora;

import org.txm.annotation.urs.Messages;

import org.txm.annotation.urs.imports.AnalecAnnotationsImporter;

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

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;

import visuAnalec.donnees.Corpus;

import visuAnalec.vue.Vue;

/**

 * Export the Analec annotation of the selected Corpus

 * 

 * @author mdecorde

 *

 */

public class ImportTEIAnnotations  extends AbstractHandler {

	@Option(name="directory",usage="the directory containing the XML-TEI-URS annotations files", widget="Folder", required=true, def="annotations")

	File directory;

	@Option(name="aamFile",usage="The Glozz model file", widget="FileOpen", required=true, def="model.aam")

	File aamFile;

	//@Option(name="standoffAnnotations",usage="select this if the directory contains standoff annotation files", widget="Boolean", required=true, def="false")

	//boolean standoffAnnotations;

	@Option(name="resetAnnotations",usage="Remove the old annotations", widget="Boolean", required=true, def="false")

	boolean resetAnnotations;

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			// Open the parameters input dialog box

			if (!ParametersDialog.open(this)) return null;

			Object first = CorporaView.getFirstSelectedObject();

			if (!(first instanceof org.txm.searchengine.cqp.corpus.CQPCorpus)) {

				System.out.println(Messages.ImportTEIAnnotations_0+first);

				return null;

			}

			final MainCorpus mainCorpus = ((org.txm.searchengine.cqp.corpus.CQPCorpus)first).getMainCorpus();

			final Corpus analecCorpus = AnalecCorpora.getCorpus(mainCorpus);

			final Vue vue = AnalecCorpora.getVue(mainCorpus);

			JobHandler job = new JobHandler(mainCorpus.getName()+Messages.ImportTEIAnnotations_1) {

				@Override

				protected IStatus run(IProgressMonitor monitor) {

					try {

						if (resetAnnotations) {

							analecCorpus.clearAnnot();

						}

						if (!importer(monitor, directory, aamFile, true, mainCorpus, analecCorpus, vue)) {

							System.out.println(Messages.ImportTEIAnnotations_2);

							return Status.CANCEL_STATUS;

						} else {

							return Status.OK_STATUS;

						}

					} catch (Throwable e) {

						System.out.println(Messages.ImportTEIAnnotations_3+e.getLocalizedMessage());

						Log.printStackTrace(e);

						return Status.CANCEL_STATUS;

					}

				}

			};

			job.schedule();

		} catch (Exception e) {

			System.out.println(Messages.ImportTEIAnnotations_4+e);

			Log.printStackTrace(e);

		}

		return null;

	}

	/**

	 * <pre>

	 * IProgressMonitor monitor = getIProgressMonitor();

	 * File directory = new File("resultdir");

	 * File aamFile = new File("model.aam");

	 * Boolean stdf = true;

	 * String name = "BROWN";

	 * MainCorpus mainCorpus = CorpusManager.getCorpusManager().getCorpus(name)

	 * Corpus analecCorpus = AnalecCorpora.getCorpus(name.toUpperCase());

	 * Vue vue = AnalecCorpora.getVue(name);

	 * 

     * ImportTEIAnnotations.importer(monitor, directory, aamFile, stdf, mainCorpus, analecCorpus, vue);

     *</pre>

	 * @param monitor

	 * @param annotationDirectory

	 * @param aamFile

	 * @param standoffAnnotations

	 * @param mainCorpus

	 * @param analecCorpus

	 * @param vue

	 * @return

	 * @throws Exception

	 */

	public static boolean importer(IProgressMonitor monitor, File annotationDirectory, File aamFile, boolean standoffAnnotations, MainCorpus mainCorpus, Corpus analecCorpus, Vue vue) throws Exception {

//		if (!standoffAnnotations) { // use stax because files are too big for DOM process

//			AnalecAnnotationsImporter importer = new AnalecAnnotationsImporter(monitor, annotationDirectory, mainCorpus, analecCorpus, vue);

//			boolean ret = importer.process();

//			if (ret) System.out.println("Done: "+analecCorpus.getToutesUnites().size()+" unites "+analecCorpus.getToutesRelations().size()+" relations "+analecCorpus.getTousSchemas().size()+" schemas.");

//			return ret;

//		} else {

//			DOMAnalecAnnotationsImporter importer = new DOMAnalecAnnotationsImporter(monitor, annotationDirectory, mainCorpus, analecCorpus, vue);

//			boolean ret = importer.process();

//			if (ret) System.out.println("Done: "+analecCorpus.getToutesUnites().size()+" unites "+analecCorpus.getToutesRelations().size()+" relations "+analecCorpus.getTousSchemas().size()+" schemas.");

//			return ret;

//		}

		//TODO: DOMAnalecAnnotationsImporter not finished

		AnalecAnnotationsImporter importer = new AnalecAnnotationsImporter(monitor, annotationDirectory, aamFile, mainCorpus, analecCorpus, vue);

		boolean ret = importer.process();

		if (ret) {

			System.out.println(Messages.ImportTEIAnnotations_5+analecCorpus.getToutesUnites().size()+Messages.ImportTEIAnnotations_6+analecCorpus.getToutesRelations().size()+Messages.ImportTEIAnnotations_7+analecCorpus.getTousSchemas().size()+Messages.ImportTEIAnnotations_8);

			mainCorpus.setIsModified(true);

			CorporaView.refreshObject(mainCorpus);

		}

		return ret;

	}

}

package org.txm.annotation.urs.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.ui.IEditorPart;

import org.eclipse.ui.IEditorReference;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.handlers.HandlerUtil;

import org.txm.annotation.urs.AnalecCorpora;

import org.txm.annotation.urs.Messages;

import org.txm.edition.rcp.editors.SynopticEditionEditor;

import org.txm.rcp.TXMWindows;

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

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

import visuAnalec.donnees.Corpus;

import visuAnalec.fichiers.FichiersJava;

public class SaveCorpus  extends AbstractHandler {

	/** The ID. */

	public static String ID = "org.txm.analec.commands.LoadAnnotationStructure"; //$NON-NLS-1$

	Corpus corpus;

	/** The selection. */

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		Object first = CorporaView.getFirstSelectedObject();

		if (!(first instanceof org.txm.searchengine.cqp.corpus.CQPCorpus)) {

			System.out.println(Messages.SaveCorpus_0+first);

			return null;

		}

		final MainCorpus mainCorpus = ((org.txm.searchengine.cqp.corpus.CQPCorpus)first).getMainCorpus();

		save(mainCorpus, event);

		return null;

	}

	public static boolean save(final MainCorpus mainCorpus, ExecutionEvent event) {

		File binaryCorpusDirectory = mainCorpus.getProjectDirectory();

		File fichierCorpus = new File(binaryCorpusDirectory, "/analec/"+mainCorpus.getID()+".ec"); //$NON-NLS-1$ //$NON-NLS-2$

		Corpus corpus = AnalecCorpora.getCorpus(mainCorpus);

		System.out.println(Messages.SaveCorpus_3+corpus+Messages.SaveCorpus_1+fichierCorpus);

		if (!AnalecCorpora.saveCorpus(mainCorpus)) {

			System.out.println(Messages.SaveCorpus_5);

			return false;

		}

		mainCorpus.setIsModified(false);

		if (event != null) {

			HandlerUtil.getActiveShell(event).getDisplay().syncExec(new Runnable() {

				@Override

				public void run() {

					CorporaView.refreshObject(mainCorpus);

					// find out which editor is using the MainCorpus

					for (IWorkbenchPage page : TXMWindows.getActiveWindow().getPages()) {

						for (IEditorReference editor_ref : page.getEditorReferences()) {

							IEditorPart editor = editor_ref.getEditor(false);

							if (editor != null && editor instanceof SynopticEditionEditor) {

								if (mainCorpus.equals(((SynopticEditionEditor)editor).getCorpus())) {

									((SynopticEditionEditor) editor).fireIsDirty();

								}

							}

						}

					}

				}

			});

		}

		return true;

	}

}

package org.txm.annotation.urs.commands;

import java.io.File;

import java.io.FilenameFilter;

import java.util.Arrays;

import org.apache.commons.io.FilenameUtils;

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.kohsuke.args4j.Option;

import org.txm.Toolbox;

import org.txm.annotation.urs.AnalecAnnotationReIndexer;

import org.txm.annotation.urs.AnalecCorpora;

import org.txm.annotation.urs.Messages;

import org.txm.objects.Project;

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

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

import org.txm.rcp.utils.JobHandler;

import org.txm.searchengine.cqp.CQPSearchEngine;

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

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

import org.txm.utils.AsciiUtils;

import org.txm.utils.DeleteDir;

import org.txm.utils.io.IOUtils;

import org.txm.utils.logger.Log;

import visuAnalec.donnees.Corpus;

import visuAnalec.fichiers.FichiersGlozz;

import visuAnalec.fichiers.FichiersJava;

public class ImportGlozzCorpus  extends AbstractHandler {

	//	@Option(name="aafile",usage="an example file", widget="File", required=true, def="text.aa")

	//	File aafile;

	//	@Option(name="acfile",usage="an example file", widget="File", required=true, def="annotations.ac")

	//	File acfile

	@Option(name="glozzDirectory",usage="A folder containing the Glozz files: aa ac and aam", widget="Folder", required=true, def="glozz")

	File glozzDirectory;

	@Option(name="aamfile",usage="The aam file to use", widget="File", required=true, def="model.aam")

	File aamfile;

	private String name;

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			// Open the parameters input dialog box

			if (!ParametersDialog.open(this)) return null;

			// END OF PARAMETERS

			if (!glozzDirectory.exists()) {

				System.out.println(Messages.ImportGlozzCorpus_0);

				return null;

			}

			name = glozzDirectory.getName();

			name = AsciiUtils.buildId(name);

			final File srcDir = new File(glozzDirectory, name);

			System.out.println(Messages.ImportGlozzCorpus_1);

			DeleteDir.deleteDirectory(srcDir);

			srcDir.mkdir();

			final File ecDir = new File(glozzDirectory, "ec"); //$NON-NLS-1$

			System.out.println(Messages.ImportGlozzCorpus_3);

			DeleteDir.deleteDirectory(ecDir);

			ecDir.mkdir();

			if (!srcDir.exists()) {

				System.out.println(Messages.ImportGlozzCorpus_4);

				return null;

			}

			if (!ecDir.exists()) {

				System.out.println(Messages.ImportGlozzCorpus_5);

				return null;

			}

			// write the TXT file WITH paragraphs

			File[] aaFiles = glozzDirectory.listFiles(new FilenameFilter() {

				@Override

				public boolean accept(File dir, String name) {

					return name.endsWith(".aa"); //$NON-NLS-1$

				}

			});

			File[] acFiles = glozzDirectory.listFiles(new FilenameFilter() {

				@Override

				public boolean accept(File dir, String name) {

					return name.endsWith(".ac"); //$NON-NLS-1$

				}

			});

			if (aaFiles == null || aaFiles.length == 0) {

				System.out.println(Messages.ImportGlozzCorpus_8+glozzDirectory);

				return false;

			}

			if (acFiles == null || acFiles.length == 0) {

				System.out.println(Messages.ImportGlozzCorpus_9+glozzDirectory);

				return false;

			}

			if (aaFiles.length != acFiles.length) {

				System.out.println(Messages.ImportGlozzCorpus_10+glozzDirectory);

				return false;

			}

			System.out.println(Messages.ImportGlozzCorpus_11+glozzDirectory);

			Arrays.sort(acFiles);

			Arrays.sort(aaFiles);

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

				File acFile = acFiles[i];

				File aaFile = aaFiles[i];

				String name = acFile.getName();

				int idx = name.indexOf("."); //$NON-NLS-1$

				if (idx > 0) name = name.substring(0, idx);

				File txtFile = new File(srcDir, name+".txt"); //$NON-NLS-1$

				File ecFile = new File(ecDir, name+".ec"); //$NON-NLS-1$

				Corpus tmpAnalecCorpus = new Corpus(); // need a temporary corpus

				if (!FichiersGlozz.importerGlozz(tmpAnalecCorpus, acFile, aaFile)) {

					System.out.println(Messages.ImportGlozzCorpus_15);

					return null;

				}

				final String texte = tmpAnalecCorpus.getTexte();

				int debParag = 0;

				Integer[] finPars = tmpAnalecCorpus.getFinParagraphes();

				StringBuffer newTexte = new StringBuffer(texte.length() + finPars.length);

				for (int iParagraph = 0 ; iParagraph < finPars.length ; iParagraph++) {

					newTexte.append(texte.substring(debParag, finPars[iParagraph])).append("\n"); //$NON-NLS-1$

					debParag = finPars[iParagraph];

				}

				IOUtils.write(txtFile, newTexte.toString()); // write the TXT file for TXM TXT import module

				FichiersJava.enregistrerCorpus(tmpAnalecCorpus, ecFile); // write for later

				if (!txtFile.exists()) {

					System.out.println(Messages.ImportGlozzCorpus_17);

					return null;

				}

			}

			Project project = Toolbox.workspace.getProject(name.toUpperCase());

			if (project != null) {

				CQPSearchEngine.getEngine().stop();

				project.delete();

			}

			project = new Project(Toolbox.workspace, name.toUpperCase());

			project.setName(name.toUpperCase());

			project.setSourceDirectory(srcDir.getAbsolutePath());

			project.setImportModuleName("txt");

			project.getEditionDefinition("default").setBuildEdition(true);

			JobHandler job = ExecuteImportScript.executeScript(project);

			if (job == null) { // job is scheduled in ExecuteImportScript.executeScript

				System.out.println(Messages.ImportGlozzCorpus_23);

				return null;

			}

			JobHandler job2 = new JobHandler(Messages.ImportGlozzCorpus_24) {

				@Override

				protected IStatus run(IProgressMonitor monitor) {

					try {

						MainCorpus corpus = CorpusManager.getCorpusManager().getCorpus(name.toUpperCase());

						if (corpus == null) {

							System.out.println("The CQP corpus was not created. Aborting.");

							return Status.CANCEL_STATUS;

						}

						Corpus analecCorpus = AnalecCorpora.getCorpus(corpus);

						analecCorpus.clearAll(); // remove all : annotations, structure

						File[] ecFiles = ecDir.listFiles();

						Arrays.sort(ecFiles);

						for (File ecFile : ecFiles) {

							FichiersJava.concatener(ecFile, analecCorpus);

						}

						System.out.println(Messages.ImportGlozzCorpus_25+aamfile);

						if (!FichiersGlozz.importerModeleGlozz(analecCorpus, aamfile)) {

							System.out.println(Messages.ImportGlozzCorpus_26);

							return Status.CANCEL_STATUS;

						}

						//					

						//					System.out.println("Importing Glozz corpus from: "+acfile+" and "+aafile);

						//					if (!FichiersGlozz.importerGlozz(analecCorpus, acfile, aafile)) {

						//						System.out.println("Error while importing Glozz corpus.");

						//						return null;

						//					}

						System.out.println(Messages.ImportGlozzCorpus_27);

						AnalecCorpora.removeCorpus(corpus); // remove old corpus if any

						AnalecAnnotationReIndexer aari = new AnalecAnnotationReIndexer(corpus, analecCorpus);

						if (!aari.process()) {

							System.out.println(Messages.ImportGlozzCorpus_28);

							return Status.CANCEL_STATUS;

						}

						System.out.println(Messages.ImportGlozzCorpus_29);

						AnalecCorpora.saveCorpus(analecCorpus);

						AnalecCorpora.getVue(analecCorpus).retablirVueParDefaut();

						System.out.println(Messages.ImportGlozzCorpus_30);

						analecCorpus.setTexte(""); // free memory //$NON-NLS-1$

						DeleteDir.deleteDirectory(ecDir); // cleaning

						DeleteDir.deleteDirectory(srcDir); // cleaning

						return Status.OK_STATUS;

					} catch (Exception e) {

						System.out.println(Messages.ImportGlozzCorpus_32+e.getLocalizedMessage());

						Log.printStackTrace(e);

						return Status.CANCEL_STATUS;

					}

				}

			};

			job2.startJob(true); // wait for the TXT import job to finish

			return null;

		} catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		return null;

	}

}

package org.txm.annotation.urs.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.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.ui.handlers.HandlerUtil;

import org.txm.Toolbox;

import org.txm.annotation.urs.AnalecCorpora;

import org.txm.annotation.urs.Messages;

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

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

import visuAnalec.donnees.Corpus;

import visuAnalec.fichiers.FichiersJava;

import visuAnalec.vue.Vue;

public class LoadVue  extends AbstractHandler {

	/** The ID. */

	public static String ID = "org.txm.analec.commands.LoadAnnotationStructure"; //$NON-NLS-1$

	/** The selection. */

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		Object first = CorporaView.getFirstSelectedObject();

		if (!(first instanceof org.txm.searchengine.cqp.corpus.CQPCorpus)) {

			System.out.println(Messages.LoadVue_0+first);

			return null;

		}

		MainCorpus mainCorpus = ((org.txm.searchengine.cqp.corpus.CQPCorpus)first).getMainCorpus();

		load(mainCorpus);

		return null;

	}

	public boolean load(MainCorpus mainCorpus) {

		System.out.println(Messages.LoadVue_1+mainCorpus.getName());

		Vue vue = AnalecCorpora.getVue(mainCorpus);

		if (!FichiersJava.ouvrirVue(vue)) {

			System.out.println(Messages.LoadVue_2);

			return false;

		}

		System.out.println(Messages.LoadVue_3);

		return true;

	}

}

package org.txm.annotation.urs.commands;

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.ui.handlers.HandlerUtil;

import org.txm.annotation.urs.AnalecCorpora;

import org.txm.annotation.urs.Messages;

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

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

import visuAnalec.donnees.Corpus;

import visuAnalec.donnees.VisuStructure;

import visuAnalec.fichiers.FichiersJava;

public class LoadStructure  extends AbstractHandler {

	/** The ID. */

	public static String ID = "org.txm.analec.commands.LoadAnnotationStructure"; //$NON-NLS-1$

	/** The selection. */

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		Object first = CorporaView.getFirstSelectedObject();

		if (!(first instanceof org.txm.searchengine.cqp.corpus.CQPCorpus)) {

			System.out.println(Messages.LoadStructure_0+first);

			return null;

		}

		MainCorpus mainCorpus = ((org.txm.searchengine.cqp.corpus.CQPCorpus)first).getMainCorpus();

		Corpus corpus = AnalecCorpora.getCorpus(mainCorpus);

//		if (VisuStructure.isOpen()) {

//			System.out.println("Structure de corpus en cours d'édition. Abandon.");

//			return null;

//		}

		return null;

	}

	public static boolean load(Corpus corpus) {

		System.out.println(Messages.LoadStructure_1+corpus);

		if (!FichiersJava.ouvrirStructure(corpus)) {

			System.out.println(Messages.LoadStructure_2);

			return false;

		}

		System.out.println(Messages.LoadStructure_3);

		return true;

	}

}

package org.txm.annotation.urs.commands;

import java.io.File;

import java.io.IOException;

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.kohsuke.args4j.Option;

import org.txm.annotation.urs.Messages;

import org.txm.annotation.urs.export.ExportToGlozzMacro;

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

import org.txm.rcp.utils.JobHandler;

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

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

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

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

import org.txm.utils.logger.Log;

public class ExportGlozzCorpus  extends AbstractHandler {

	@Option(name="exportDirectory",usage="the result directory ", widget="Folder", required=true, def="result directory")

	File exportDirectory;

	@Option(name="unit_type",usage="A unit type to export", widget="String", required=true, def="MENTION")

	String unit_type;

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			// Open the parameters input dialog box

			if (!ParametersDialog.open(this)) return null;

			Object first = CorporaView.getFirstSelectedObject();

			if (!(first instanceof org.txm.searchengine.cqp.corpus.CQPCorpus)) {

				System.out.println(Messages.ExportGlozzCorpus_0+first);

				return null;

			}

			final MainCorpus mainCorpus = ((org.txm.searchengine.cqp.corpus.CQPCorpus)first).getMainCorpus();

			JobHandler job = new JobHandler(mainCorpus.getName()+Messages.ExportGlozzCorpus_1) {

				@Override

				protected IStatus run(IProgressMonitor monitor) {

					this.runInit(monitor);

					try {

						export(exportDirectory, mainCorpus, unit_type);

					} catch (ThreadDeath e) {

						System.out.println(Messages.ExportGlozzCorpus_2);

					} catch (Throwable e) {

						System.out.println(Messages.ExportGlozzCorpus_3+e.getLocalizedMessage());

						Log.printStackTrace(e);

						return Status.CANCEL_STATUS;

					}

					return Status.OK_STATUS;

				}

			};

			job.schedule();

			return null;

		} catch (Throwable e) {

			System.out.println(Messages.ExportGlozzCorpus_4+e.getLocalizedMessage());

			Log.printStackTrace(e);

		}

		return null;

	}

	public static void export(File exportDirectory, MainCorpus mainCorpus, String unit_type) throws NumberFormatException, IOException, CqiServerError, CqiClientException {

		ExportToGlozzMacro exporter = new ExportToGlozzMacro();

		File exportFile = new File(exportDirectory, mainCorpus.getID());

		exporter.doExport(mainCorpus, unit_type, exportFile.getAbsolutePath());

		return;

	}

}

package org.txm.annotation.urs.commands;

import java.awt.Dimension;