Laboratoire ICAR » Plateforme TXM

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

				CQPCorpus corpus = conc.getCorpus();

			else if (selection instanceof CQPCorpus) {

				cooc = new Cooccurrence((CQPCorpus) selection);

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

		CQPCorpus corpus = cooc.getCorpus();

import org.eclipse.jface.action.MenuManager;

import org.eclipse.swt.custom.ScrolledComposite;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.events.KeyListener;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.Text;

import org.txm.concordance.core.preferences.ConcordancePreferences;

import org.txm.rcp.editors.listeners.ComputeListener;

import org.txm.rcp.messages.TXMUIMessages;

import org.txm.rcp.preferences.RCPPreferences;

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

	@Parameter(key=CooccurrencePreferences.QUERY)

	public CQPCorpus getCorpus() {

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

	CQPCorpus corpus;

	public EmpantWidget(Composite parent, int style, CQPCorpus corpus) {

import java.util.Arrays;

import org.osgi.service.prefs.BackingStoreException;

import org.txm.objects.BaseOldParameters;

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

	public static AnnotationManager getAnnotationManager(CQPCorpus corpus) throws Exception{

	public static KnowledgeRepository getKnowledgeRepository(CQPCorpus corpus, String name) {

	public static Element getKnowledgeRepositoryElement(BaseOldParameters params, String name) {

	public static List<String> getKnowledgeRepositoryNames(BaseOldParameters params) {

	public static List<String> getKnowledgeRepositoryNames(CQPCorpus corpus) {

		String[] names;

		try {

			names = base.getPreferences().getNode("KnowledgeRepository").node("names").keys();

			return Arrays.asList(names); // getKnowledgeRepositoryNames(params);

		} catch (BackingStoreException e) {

			e.printStackTrace();

			return new ArrayList<>();

		}

	public static Element createKnowledgeRepositoryElement(BaseOldParameters params, String name) {

	public boolean[] mustLoginToKnowledgeRepository(CQPCorpus corpus, String kr_name) {

import org.txm.objects.BaseOldParameters;

		//FIXME read KR configuration from Project preferences

		BaseOldParameters bp = null;//corpus.getProject().getProjectParameters();

		List<String> textsIds = corpus.getProject().getTextsID();

		List<String> textsIds = corpus.getProject().getTextsID();

import org.txm.Toolbox;

			writer.writeAttribute("date", Toolbox.dateformat.format(new Date()));

import org.txm.Toolbox;

		this.date = Toolbox.dateformat.format(new Date());

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

		if(selection instanceof CQPCorpus) {

			textsBalance = new TextsBalance((CQPCorpus) selection);

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

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

	public Progression(CQPCorpus parent)	{

	public static boolean canRunProgression(CQPCorpus corpus) {

	public CQPCorpus getCorpus() {

		return (CQPCorpus) this.parent;

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

					CQPCorpus.getFirstParentCorpus(this.getResult()).getOrderedProperties(),

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

		CQPCorpus corpus = coocs.getCorpus();

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

					CQPCorpus corpus = qi.getCorpus();

	private QueryAutoCooccurrence computeCooc(Shell shell, CQPCorpus corpus, QueryIndex element, CoocMatrixDialog dialog) {

		CQPCorpus corpus;

		public CoocMatrixDialog(Shell parentShell, CQPCorpus corpus) {

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

					if (!(element instanceof CQPCorpus)) {

					CQPCorpus corpus = ((CQPCorpus)element);

	private QueryCooccurrence computeCooc(Shell shell, CQPCorpus corpus, CoocMatrixDialog dialog) throws IOException {

		CQPCorpus corpus;

		public CoocMatrixDialog(Shell parentShell, CQPCorpus corpus) {

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

	protected CQPCorpus corpus;

	public QueryAutoCooccurrence(CQPCorpus corpus) {

	public CQPCorpus getParent() {

	public CQPCorpus getCorpus() {

		CQPCorpus corpus = this.getCorpus();

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

	protected CQPCorpus corpus;

	public QueryCooccurrence(CQPCorpus corpus, 

	public CQPCorpus getCorpus() {

		CQPCorpus corpus = this.getCorpus();

import org.txm.Toolbox;

/**

 * Copy all Groovy scripts in TXMHome directory

 * 

 * @author mdecorde

 *

 */

		File txmhomedir = new File(Toolbox.getTxmHomePath());

package org.txm.groovy.core

File workspace = new File("/home/mdecorde/workspace047")

def langs = ["fr", "ru"]

for (File project : workspace.listFiles()) {

	if (!project.isDirectory()) continue;

	File osgiinf = new File(project, "OSGI-INF/l10n")

	if (!osgiinf.exists()) continue;

	println project.getName()

	File defaultFile = new File(osgiinf, "bundle.properties")

	for (def lang : langs) {

		File langFile = new File(osgiinf, "bundle_"+lang+".properties");

		if (!langFile.exists()) {

			langFile.createNewFile()

		}

	}

}

package org.txm.groovy.core;

import org.eclipse.core.runtime.IProgressMonitor;

/**

 * IProgressMonitor wrapper 

 * 

 * adds some methods for Groovy scripts

 * 

 * @author mdecorde

 *

 */

public class GroovyProgressMonitor implements IProgressMonitor{

	private IProgressMonitor monitor;

	public GroovyProgressMonitor(IProgressMonitor monitor) {

		this.monitor = monitor;

	}

	@Override

	public void beginTask(String name, int totalWork) {

		if (monitor == null) return;

		monitor.beginTask(name, totalWork);

	}

	@Override

	public void done() {

		if (monitor == null) return;

		monitor.done();

	}

	@Override

	public void internalWorked(double work) {

		if (monitor == null) return;

		monitor.internalWorked(work);

	}

	@Override

	public boolean isCanceled() {

		if (monitor == null) return false;

		return monitor.isCanceled();

	}

	@Override

	public void setCanceled(boolean value) {

		if (monitor == null) return;

		monitor.setCanceled(value);

	}

	@Override

	public void setTaskName(String name) {

		if (monitor == null) return;

		monitor.setTaskName(name);

	}

	@Override

	public void subTask(String name) {

		// TODO Auto-generated method stub

	}

	@Override

	public void worked(int work) {

		if (monitor == null) return;

		monitor.worked(work);

	}

	public void worked(int work, String message) {

		if (monitor == null) return;

		monitor.worked(work);

		monitor.setTaskName(message);

	}

}

package org.txm.groovy.core;

import java.io.File;

import java.util.logging.Level;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.txm.Toolbox;

import org.txm.annotation.core.AnnotationEngine;

import org.txm.core.engines.Engine;

import org.txm.core.engines.EngineType;

import org.txm.core.engines.ScriptedImportEngine;

import org.txm.objects.Project;

import org.txm.searchengine.cqp.CQPSearchEngine;

import org.txm.tokenizer.TokenizerClasses;

import org.txm.utils.ExecTimer;

import org.txm.utils.logger.Log;

import groovy.lang.Binding;

public class GroovyScriptedImportEngine extends ScriptedImportEngine {

	File importer, compiler, pager, annotate;

	public GroovyScriptedImportEngine(File directory) {

		super(directory.getName(), new File(directory, directory.getName()+"Loader.groovy"));

		importer = new File(directory, "importer.groovy");

		compiler = new File(directory, "compiler.groovy");

		pager = new File(directory, "pager.groovy");

		annotate = new File(directory, "annotate.groovy");

	}

	@Override

	public IStatus _build(Project project, IProgressMonitor monitor) {

		try {

			// check if TreeTagger if ready

			boolean annotate = project.getAnnotate();

			if (annotate) {

				Engine e = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine("TreeTagger");

				if (e == null) {

					System.out.println("Error: no TreeTagger annotation engine found to annotate the corpus. Aborting");

					return null;

				}

				AnnotationEngine engine = (AnnotationEngine) e;

				if (!engine.isRunning()) {

					System.out.println("Error: TreeTagger annotation engine is not ready please check TXM > Advance > TAL > TreeTagger preferences. Aborting");

					return null;

				}

			}

			// the binary directory which is going to be created

			final File basedir = project.getProjectDirectory();

//			final File tempBinDirectory = new File(basedir.getAbsolutePath()+"_temp"); //$NON-NLS-1$

//			final File errorBinDirectory = new File(basedir.getAbsolutePath()+"_error"); //$NON-NLS-1$

//			if (tempBinDirectory.exists()) DeleteDir.deleteDirectory(tempBinDirectory);

//			if (errorBinDirectory.exists()) DeleteDir.deleteDirectory(errorBinDirectory);

			//this.setCurrentMonitor(monitor);

			monitor.beginTask("Importing sources" + project.getSrcdir(), 100); //$NON-NLS-1$

			//org.txm.Toolbox.shutdownSearchEngine();

			monitor.worked(5);

			GSERunner gse = GSERunner.buildDefaultGSE(mainScript);

			Binding binding = new Binding();

			binding.setProperty("projectBinding", project); //$NON-NLS-1$

			binding.setProperty("monitor", new GroovyProgressMonitor(monitor)); //$NON-NLS-1$

			boolean logLevel = Log.getLevel().intValue() < Level.WARNING.intValue();			

			binding.setProperty("debug", logLevel); //$NON-NLS-1$

			binding.setProperty("readyToLoad", Boolean.FALSE); //$NON-NLS-1$

			//System.out.println("script="+script);

			TokenizerClasses.reset();

			if (!TokenizerClasses.loadFromProject(project.getPreferences())) {

				System.out.println("Error: failed to load tokenizer parameters");

				monitor.done();

//				if (basedir.exists()) basedir.renameTo(errorBinDirectory);

//				if (tempBinDirectory.exists()) tempBinDirectory.renameTo(basedir);

				return Status.CANCEL_STATUS;

			}

			ExecTimer.start();

			Log.info("Start of Groovy import script" + mainScript.getAbsolutePath()); //$NON-NLS-1$

			gse.run(mainScript.getAbsolutePath(), binding); // run the groovy import script

			System.out.println("\nEnd of Groovy import script: "+ExecTimer.stop()); //$NON-NLS-1$

			monitor.worked(90);

			TokenizerClasses.reset();

			Object ready = binding.getVariable("readyToLoad"); //$NON-NLS-1$

			if (ready != null && ready instanceof Boolean) {

				Boolean readyToLoad = (Boolean)ready;

				//System.out.println("TRY TO LOAD THE BINARY CORPUS CREATED: "+basedir);

				if (readyToLoad) {

//					base = LoadBinaryCorpus.loadBinaryCorpusAsDirectory(basedir);

//					if (base == null) {

//						System.out.println(TXMUIMessages.ExecuteScriptImport_8);

//						if (basedir.exists()) basedir.renameTo(errorBinDirectory);

//						if (tempBinDirectory.exists()) tempBinDirectory.renameTo(basedir);

//						return Status.CANCEL_STATUS;

//					}

//					this.acquireSemaphore();

//					Log.info("Save workspace"); //$NON-NLS-1$

//					Toolbox.workspace.save();

					Log.info("Restart Toolbox search engine"); //$NON-NLS-1$

					//Toolbox.restartWorkspace(null);

					Toolbox.getEngineManager(EngineType.SEARCH).restartEngines();

//					DeleteDir.deleteDirectory(tempBinDirectory);

					//							IWorkspace workspace = ResourcesPlugin.getWorkspace();

					//							IProject newProject = workspace.getRoot().getProject(base.getName());

					//							newProject.create(monitor);

					//							newProject.open(monitor);

					//							IFolder srcFolder = newProject.getFolder("src");

					//							IPath path = new Path(params.rootDir);

					//							srcFolder.createLink(path, IResource.ALLOW_MISSING_LOCAL, monitor);

				} else {

					System.out.println("Error: import not correctly ended. See console messages.");

//					if (basedir.exists()) basedir.renameTo(errorBinDirectory);

//					if (tempBinDirectory.exists()) tempBinDirectory.renameTo(basedir);

					return new Status(Status.ERROR, "org.txm.groovy.core", "Import not correclty ended. See console messages.");

				}

			}

		} catch (ThreadDeath td) {

			return Status.CANCEL_STATUS;

		} catch (Exception e) {

			//System.out.println(NLS.bind(TXMUIMessages.RunGroovyScript_8, e));

			Log.printStackTrace(e);

			return new Status(Status.ERROR, "org.txm.groovy.core", e.getMessage());

		} finally {

			if (!CQPSearchEngine.isInitialized()) { // the import failed

				monitor.setTaskName("Restarting Toolbox search engine"); //$NON-NLS-1$

				Toolbox.restartWorkspace(monitor);

				Toolbox.getEngineManager(EngineType.SEARCH).restartEngines();

			}

		}

		System.gc();

		return Status.OK_STATUS;

	}

}

package org.txm.groovy.core;

import java.util.HashSet;

public class TXMClassLoader extends ClassLoader {

	private HashSet<ClassLoader> loaders;

	public TXMClassLoader(HashSet<ClassLoader> loaders2) {

		this.loaders  = loaders2;

	}

    public Class findClass(String name) throws ClassNotFoundException {

    	try { // try with the common one

    		return this.getClass().getClassLoader().loadClass(name);

    	} catch(Exception e) {}

        for (ClassLoader cl : loaders) {

        	try {

        		return cl.loadClass(name);

        	} catch(Exception e) {}

        }

        throw new ClassNotFoundException(name);

    }

}

package org.txm.groovy.core;

import java.io.File;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.txm.Toolbox;

import org.txm.core.engines.ImportEngine;

import org.txm.core.engines.ImportEngines;

import org.txm.core.engines.ScriptedImportEngine;

import org.txm.objects.Project;

public class GroovyImportEngine extends ImportEngine {

	@Override

	public boolean isRunning() {

		return false;

	}

	@Override

	public boolean initialize() throws Exception {

		ImportEngines engines = Toolbox.getImportEngines();

		File importsPackageDirectory = new File(Toolbox.getTxmHomePath(), "scripts/groovy/user/org/txm/scripts/importer");

		if (!importsPackageDirectory.exists()) {

			return false;

		}

		for (File dir : importsPackageDirectory.listFiles()) {

			if (!dir.isDirectory()) continue;

			if (dir.isHidden()) continue;

			String name = dir.getName();

			File loader = new File(dir, name+"Loader.groovy");

			if (loader.exists()) {

				ScriptedImportEngine sengine = new GroovyScriptedImportEngine(dir);

				if (engines.getEngine(name) == null) {

					engines.put(name, sengine);

				} else {

					System.out.println("Scripted import module in "+dir+" not registered since one with the same name is registered.");

				}

			}

		}

		return true;

	}

	@Override

	public boolean start(IProgressMonitor monitor) throws Exception {

		// TODO Auto-generated method stub

		return true;

	}

	@Override

	public boolean stop() throws Exception {

		// TODO Auto-generated method stub

		return true;

	}

	@Override

	public String getName() {

		return "groovy scripted imports installers - not meant to be used";

	}

	@Override

	public IStatus build(Project project, IProgressMonitor monitor) {

		return Status.CANCEL_STATUS;

	}

}

package org.txm.groovy.core;

import java.io.File;

import java.io.FilenameFilter;

import java.io.IOException;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import org.codehaus.groovy.control.CompilerConfiguration;

import org.codehaus.groovy.control.customizers.ImportCustomizer;

import org.eclipse.core.internal.runtime.InternalPlatform;

import org.osgi.framework.Bundle;

import org.osgi.framework.BundleContext;

import org.osgi.framework.wiring.BundleWiring;

import org.txm.Toolbox;

import org.txm.utils.logger.Log;

import cern.colt.Arrays;

import groovy.lang.Binding;

import groovy.util.GroovyScriptEngine;

import groovy.util.ResourceException;

import groovy.util.ScriptException;

/**

 * GroovyScriptEngine wrapper for TXM scripts and macros

 * 

 * @author mdecorde

 *

 */

public class GSERunner extends GroovyScriptEngine {

	protected GSERunner(String[] urls) throws IOException {

		super(urls, getTXMClassLoader());

	}

	protected static GSERunner defaultGSE;

	protected static String defaultScriptRootDir = "";

	public static void clearDefaultGSE() {

		defaultGSE = null;

		defaultScriptRootDir = "";

	}

	/**

	 * Build a GSERunner with default paths : user, macro, import and library path

	 * 

	 * @param scriptRootDir if null uses Toolbox home directory

	 * @param script

	 * @return

	 */

	public static GSERunner buildDefaultGSE(File script) {

		String scriptRootDir = new File(Toolbox.getTxmHomePath(), "scripts/groovy/").getAbsolutePath();

		// check if script root dir was changed

		if (defaultScriptRootDir.equals(scriptRootDir) && defaultGSE != null) {

			try {

				defaultGSE.getGroovyClassLoader().addURL(new URL("file://"+script.getParent()));

			} catch (MalformedURLException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

			return defaultGSE;

		}

		if (scriptRootDir == null) {

			scriptRootDir = new File(Toolbox.getTxmHomePath(), "scripts/groovy/").getAbsolutePath();

		}

		String[] roots = new String[] { 

				scriptRootDir+"/user/", //$NON-NLS-1$

				scriptRootDir+"/system/", //$NON-NLS-1$

		}; 

		try {

			defaultScriptRootDir = scriptRootDir;

			Log.info("GSE roots: "+Arrays.toString(roots));

			defaultGSE = new GSERunner(roots);

		} catch (IOException e) {

			e.printStackTrace();

			return null;

		}

		ImportCustomizer imports = new ImportCustomizer();

		imports.addStarImports("org.txm.rcp.utils", 

				"org.txm.utils", 

				"org.txm", 

				"org.kohsuke.args4j", 

				"org.txm.rcp.swt.widget.parameters");

		imports.addImports("groovy.transform.Field");

		CompilerConfiguration configuration = new CompilerConfiguration();

		configuration.addCompilationCustomizers(imports);

		defaultGSE.setConfig(configuration);

		File jardir = new File(scriptRootDir,"lib"); //$NON-NLS-1$

		if (jardir.exists() && jardir.isDirectory()) {

			for (File f: jardir.listFiles(new FilenameFilter() {

				@Override

				public boolean accept(File dir, String name) {

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

				}

			}))

			{

				try {

					defaultGSE.getGroovyClassLoader().addURL(f.toURI().toURL());

				} catch (MalformedURLException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

		}	

		defaultGSE.getGroovyClassLoader().addClasspath(scriptRootDir); // for the .class files if any

		return defaultGSE;

	}

	/**

	 * 

	 * @return a class loader containing all bundles activated in TXM

	 */

	protected static ClassLoader getTXMClassLoader() {

		HashSet<ClassLoader> loaders = new HashSet<ClassLoader>();

		BundleContext bundleContext = InternalPlatform.getDefault().getBundleContext();

		Bundle[] bundles = bundleContext.getBundles();

//		java.util.Arrays.sort(bundles, new Comparator<Bundle>() {

//

//			@Override

//			public int compare(Bundle o1, Bundle o2) {

//				if (o1.getSymbolicName().startsWith("org.txm")) return 1;

//				return -1;

//			}

//		});

		for (Bundle b : bundles) {

			if (b == null) continue;

			if (!b.getSymbolicName().startsWith("org.txm")) continue;

			BundleWiring bundleWiring = b.adapt(BundleWiring.class);

			if (bundleWiring == null) {

				//System.out.println("GSERunner.createGSERunner(): NO wiring: " + b.getSymbolicName());

			} else if (bundleWiring.getClassLoader() != null) {

				loaders.add(bundleWiring.getClassLoader());

				//FIXME: debug

				//System.out.println("GSERunner.createGSERunner(): ADD class loader: " + b.getSymbolicName());

			} else {

				//System.out.println("GSERunner.createGSERunner(): NO  class loader: " + b.getSymbolicName());

			}

		}

		Log.info("Initializing TXMClassLoader with " + loaders.size() + " bundles.");

		return new TXMClassLoader(loaders);

	}

	/**

	 * 

	 * Simplify the call a Groovy script within a Groovy script and allow to send named and typed arguments

	 * 

	 * @param clazz

	 * @param args

	 * @return

	 * @throws ResourceException

	 * @throws ScriptException

	 */

	@SuppressWarnings("rawtypes")

	public Object run(Class clazz, Map args) throws ResourceException, ScriptException {

		return run(clazz.getCanonicalName().replace(".", "/")+".groovy", new Binding(args));

	}

	/**

	 * Convenience method exactly the same as calling

	 * run(clazz, ["args":args])

	 * 

	 * @param clazz

	 * @param args

	 * @return

	 * @throws ResourceException

	 * @throws ScriptException

	 */

	@SuppressWarnings("rawtypes")

	public Object runMacro(Class clazz, Map args) throws ResourceException, ScriptException {

		HashMap<String, Object> arrangedMap = new HashMap<String, Object>();

		arrangedMap.put("args", args);

		return run(clazz.getCanonicalName().replace(".", "/")+".groovy", new Binding(arrangedMap));

	}

	/**

	 * Convenience method exactly the same as calling

	 * run(clazz, ["args":[:]])

	 * 

	 * @param clazz

	 * @param args

	 * @return

	 * @throws ResourceException

	 * @throws ScriptException

	 */

	@SuppressWarnings("rawtypes")

	public Object runMacro(Class clazz) throws ResourceException, ScriptException {

		HashMap<String, Object> arrangedMap = new HashMap<String, Object>();

		arrangedMap.put("args", new HashMap<String, Object>());

		return run(clazz.getCanonicalName().replace(".", "/")+".groovy", new Binding(arrangedMap));

	}

}

import org.txm.objects.*;

Project project;

boolean debug = org.txm.utils.logger.Log.isPrintingErrors();

try {project=projectBinding;MONITOR=monitor} catch (Exception)

{	}

if (project == null) { println "no project set. Aborting"; return; }

String corpusname = project.getName();

String basename = corpusname

String rootDir = project.getSrcdir();

String lang = project.getLang()

String encoding = project.getEncoding()

boolean annotate = project.getAnnotate()

String xsl = project.getFrontXSL();

def xslParams = project.getXsltParameters();

int wordsPerPage = project.getEditionDefinition("default").getWordsPerPage()

boolean build_edition = project.getEditionDefinition("default").getBuildEdition()

File binDir = project.getProjectDirectory();

		Text t = new Text(project);

		t.setName(txtname);

		t.setSourceFile(srcfile)

		t.setTXMFile(srcfile)

		Edition edition = new Edition(t);

		edition.setName("default");

		edition.setIndex(outdir.getAbsolutePath());

			edition.addPage(""+(++i), wordid);