Laboratoire ICAR » Plateforme TXM

- link to LexicalTable

- link to Matrice MotsxMots

- link to WordCloud 

- Adapter :

	getAdapter

	create Adapter

	declare Adapter in plugin.xml

- CorporaView :

	status line

	open result

- Delete Object

	implémenter Function devrait suffire

- LexicalTableImpl : createLexicalImpl

- Command : ComputeQueryIndex

- Editor

- Editor input

- WordCloud : constructeur

- WordCloud editor : init

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

<projectDescription>

	<name>QueryIndexRCP</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 queryindexrcp;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.osgi.framework.BundleContext;

/**

 * The activator class controls the plug-in life cycle

 */

public class Activator extends AbstractUIPlugin {

	// The plug-in ID

	public static final String PLUGIN_ID = "QueryIndexRCP"; //$NON-NLS-1$

	// The shared instance

	private static Activator plugin;

	/**

	 * The constructor

	 */

	public Activator() {

	}

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)

	 */

	public void start(BundleContext context) throws Exception {

		super.start(context);

		plugin = this;

	}

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)

	 */

	public void stop(BundleContext context) throws Exception {

		plugin = null;

		super.stop(context);

	}

	/**

	 * Returns the shared instance

	 *

	 * @return the shared instance

	 */

	public static Activator getDefault() {

		return plugin;

	}

	/**

	 * Returns an image descriptor for the image file at the given

	 * plug-in relative path

	 *

	 * @param path the path

	 * @return the image descriptor

	 */

	public static ImageDescriptor getImageDescriptor(String path) {

		return imageDescriptorFromPlugin(PLUGIN_ID, path);

	}

}

package queryindexrcp.actions;

import org.eclipse.jface.action.IAction;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.IWorkbenchWindowActionDelegate;

import org.eclipse.jface.dialogs.MessageDialog;

/**

 * Our sample action implements workbench action delegate.

 * The action proxy will be created by the workbench and

 * shown in the UI. When the user tries to use the action,

 * this delegate will be created and execution will be 

 * delegated to it.

 * @see IWorkbenchWindowActionDelegate

 */

public class SampleAction implements IWorkbenchWindowActionDelegate {

	private IWorkbenchWindow window;

	/**

	 * The constructor.

	 */

	public SampleAction() {

	}

	/**

	 * The action has been activated. The argument of the

	 * method represents the 'real' action sitting

	 * in the workbench UI.

	 * @see IWorkbenchWindowActionDelegate#run

	 */

	public void run(IAction action) {

		MessageDialog.openInformation(

			window.getShell(),

			"QueryIndexRCP",

			"Hello, Eclipse world");

	}

	/**

	 * Selection in the workbench has been changed. We 

	 * can change the state of the 'real' action here

	 * if we want, but this can only happen after 

	 * the delegate has been created.

	 * @see IWorkbenchWindowActionDelegate#selectionChanged

	 */

	public void selectionChanged(IAction action, ISelection selection) {

	}

	/**

	 * We can use this method to dispose of any system

	 * resources we previously allocated.

	 * @see IWorkbenchWindowActionDelegate#dispose

	 */

	public void dispose() {

	}

	/**

	 * We will cache window object in order to

	 * be able to provide parent shell for the message dialog.

	 * @see IWorkbenchWindowActionDelegate#init

	 */

	public void init(IWorkbenchWindow window) {

		this.window = window;

	}

}

// Copyright © 2010-2013 ENS de Lyon.

package queryindexrcp.adapters;

import org.eclipse.core.runtime.IAdapterFactory;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.ui.model.IWorkbenchAdapter;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.txm.functions.queryindex.QueryIndex;

import org.txm.rcp.Application;

import org.txm.rcp.IImageKeys;

/**

 * A factory for creating Adapter objects.

 * 

 * @author mdecorde

 */

public class AdapterFactory implements IAdapterFactory {

	/** The Index adapter. */

	private IWorkbenchAdapter QueryIndexAdapter = new IWorkbenchAdapter() {

		@Override

		public Object[] getChildren(Object o) {

			return new Object[0];

		}

		@Override

		public ImageDescriptor getImageDescriptor(Object object) {

			return AbstractUIPlugin.imageDescriptorFromPlugin(

					Application.PLUGIN_ID, IImageKeys.QUERYINDEX);

		}

		@Override

		public String getLabel(Object o) {

			return ((QueryIndex) o).getName();

		}

		@Override

		public Object getParent(Object o) {

			return ((QueryIndex) o).getCorpus();

		}

	};

	/**

	 * Gets the adapter.

	 *

	 * @param adaptableObject the adaptable object

	 * @param adapterType the adapter type

	 * @return the adapter

	 * @see org.eclipse.core.runtime.IAdapterFactory#getAdapter(java.lang.Object,

	 * java.lang.Class)

	 */

	@Override

	public Object getAdapter(Object adaptableObject, Class adapterType) {

		if (adapterType == IWorkbenchAdapter.class

				&& adaptableObject instanceof QueryIndex)

			return QueryIndexAdapter;

		return null;

	}

	/**

	 * Gets the adapter list.

	 *

	 * @return the adapter list

	 * @see org.eclipse.core.runtime.IAdapterFactory#getAdapterList()

	 */

	@Override

	@SuppressWarnings("unchecked") //$NON-NLS-1$

	public Class[] getAdapterList() {

		return new Class[] { IWorkbenchAdapter.class };

	}

}

package org.txm.functions.queryindex;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.ui.model.IWorkbenchAdapter;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.core.results.TXMResult;

import org.txm.index.core.functions.LineComparator.SortMode;

import org.txm.index.core.messages.IndexCoreMessages;

import org.txm.lexicaltable.core.functions.LexicalTable;

import org.txm.lexicaltable.core.statsengine.r.data.LexicalTableImpl;

import org.txm.rcp.IImageKeys;

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

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

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

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

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

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

import org.txm.statsengine.r.core.exceptions.RWorkspaceException;

import org.txm.utils.logger.Log;

public class QueryIndex extends TXMResult implements IAdaptable {

	Corpus corpus;

	Partition partition;

	LinkedHashMap<String, QueryIndexLine> lines = new LinkedHashMap<String, QueryIndexLine>();

	List<String> partnames;

	//	private int FilterFmin;

	//	private int FilterFmax;

	//	private int FilterVmax;

	//	public int getFilterFmin() {

	//		return FilterFmin;

	//	}

	//

	//	public int getFilterFmax() {

	//		return FilterFmax;

	//	}

	//

	//	public int getFilterVmax() {

	//		return FilterVmax;

	//	}

	/** The writer. */

	private OutputStreamWriter writer;

	public int getT() {

		int t = 0;

		for (QueryIndexLine line : lines.values()) {

			t += line.getFrequency();

		}

		return t;

	}

	public int getFmin() {

		int t = 999999999;

		for (QueryIndexLine line : lines.values()) {

			int f = line.getFrequency();

			if (f < t) t = f;

		}

		return t;

	}

	public int getFmax() {

		int t = 0;

		for (QueryIndexLine line : lines.values()) {

			int f = line.getFrequency();

			if (f > t) t = f;

		}

		return t;

	}

	public int getV() {

		return lines.values().size();

	}

	public QueryIndex(Corpus corpus) {

		this.corpus = corpus;

		partnames = Arrays.asList(corpus.getName());

	}

	public String getName() {

		if (partition != null)

			return partition.getName();

		return corpus.getName();

	}

	public TXMResult getParent() {

		if (partition != null) return partition;

		return corpus;

	}

	public QueryIndex(Partition partition) {

		this.corpus = partition.getCorpus();

		this.partition = partition;

		partnames = partition.getPartNames();

	}

	public Corpus getCorpus() {

		return corpus;

	}

	public Partition getPartition() {

		return partition;

	}

	public Collection<QueryIndexLine> getLines() {

		return lines.values();

	}

	public LinkedHashMap<String, QueryIndexLine> getLinesHash() {

		return lines;

	}

	//	public void filterLines(int fmin, int fmax) {

	//		System.out.println("filter lines fmin="+fmin +" fmax="+fmax );

	//		this.FilterFmin = fmin;

	//		this.FilterFmax = fmax;

	//	}

	int multi = 1;

	public void sortLines(SortMode mode, boolean revert) {

		multi = 1;

		if (revert) multi = -1;

		List<Map.Entry<String, QueryIndexLine>> entries =

				new ArrayList<Map.Entry<String, QueryIndexLine>>(lines.entrySet());

		if (mode == SortMode.FREQUNIT) {

			Collections.sort(entries, new Comparator<Map.Entry<String, QueryIndexLine>>() {

				public int compare(Map.Entry<String, QueryIndexLine> a, Map.Entry<String, QueryIndexLine> b){

					int ret = multi * (a.getValue().getFrequency() - b.getValue().getFrequency());

					if (ret == 0) {

						return multi * a.getValue().getName().compareTo(b.getValue().getName());

					}

					return ret;

				}

			});

		} else if (mode == SortMode.FREQ) {

			Collections.sort(entries, new Comparator<Map.Entry<String, QueryIndexLine>>() {

				public int compare(Map.Entry<String, QueryIndexLine> a, Map.Entry<String, QueryIndexLine> b){

					return multi * (a.getValue().getFrequency() - b.getValue().getFrequency());

				}

			});

		} else if (mode == SortMode.UNIT) {

			Collections.sort(entries, new Comparator<Map.Entry<String, QueryIndexLine>>() {

				public int compare(Map.Entry<String, QueryIndexLine> a, Map.Entry<String, QueryIndexLine> b){

					return multi * a.getValue().getName().compareTo(b.getValue().getName());

				}

			});

		} else if (mode == SortMode.UNITFREQ) {

			Collections.sort(entries, new Comparator<Map.Entry<String, QueryIndexLine>>() {

				public int compare(Map.Entry<String, QueryIndexLine> a, Map.Entry<String, QueryIndexLine> b){

					int ret = multi * a.getValue().getName().compareTo(b.getValue().getName());

					if (ret == 0) {

						return multi * (a.getValue().getFrequency() - b.getValue().getFrequency());

					}

					return ret;

				}

			});

		}

		LinkedHashMap<String, QueryIndexLine> sortedMap = new LinkedHashMap<String, QueryIndexLine>();

		for (Map.Entry<String, QueryIndexLine> entry : entries) {

			sortedMap.put(entry.getKey(), entry.getValue());

		}

		lines = sortedMap;

	}

	//	public void cut(int vmax) {

	//		System.out.println("TODO cut tmax="+vmax );

	//		this.FilterVmax = vmax;

	//	}

	public boolean isComputedWithPartition() {

		return partition != null;

	}

	public void addLinesFromFile(File propFile) throws CqiClientException, IOException {

		BufferedReader reader = new BufferedReader(new InputStreamReader(

				new FileInputStream(propFile), "UTF-8")); //$NON-NLS-1$

		String line = reader.readLine();

		while (line != null) {

			String[] split = line.split("=", 2); //$NON-NLS-1$

			if (split.length == 2) {

				if (hasLine(split[0])) {

					System.out.println(TXMCoreMessages.QueryIndex_2+line);

				} else {

					if (addLine(split[0], new Query(split[1])) == null) {

						System.out.println(TXMCoreMessages.QueryIndex_3+line);

					}

				}

			}

			line = reader.readLine();

		}

		reader.close();

	}

	/**

	 * Write all the lines on a writer.

	 *

	 * @param outfile the outfile

	 * @param encoding the encoding

	 * @param colseparator the colseparator

	 * @param txtseparator the txtseparator

	 * @return true, if successful

	 */

	public boolean toTxt(File outfile, String encoding, String colseparator, String txtseparator) {

		try {

			toTxt(outfile, 0, lines.size(), encoding, colseparator, txtseparator);

		} catch (Exception e) {

			System.err.println(IndexCoreMessages.Index_7 + Log.toString(e));

			return false;

		}

		return true;

	}

	/**

	 * Write the lines between from and to on a writer.

	 *

	 * @param outfile the outfile

	 * @param from The first line to be written

	 * @param to The last line to be writen

	 * @param encoding the encoding

	 * @param colseparator the colseparator

	 * @param txtseparator the txtseparator

	 * @throws CqiClientException the cqi client exception

	 * @throws IOException Signals that an I/O exception has occurred.

	 */

	public void toTxt(File outfile, int from, int to, String encoding, String colseparator, String txtseparator)

			throws CqiClientException, IOException {

		// NK: writer declared as class attribute to perform a clean if the operation is interrupted

		this.writer = new OutputStreamWriter(new FileOutputStream(outfile),

				encoding); 

		String header = "Queries"; //$NON-NLS-1$

		header = txtseparator+ header.substring(0, header.length() - 1) +txtseparator;

		header += colseparator+ txtseparator+ "F" + txtseparator; //$NON-NLS-1$

		if (partnames.size() > 1)

			for (int j = 0; j < partnames.size(); j++)

				header += colseparator + txtseparator+ partnames.get(j).replace(txtseparator, txtseparator+txtseparator)+txtseparator; 

		header += "\n"; //$NON-NLS-1$

		writer.write(header);

		// for(Line ligne: lines)

		for (String name : lines.keySet()) {

			QueryIndexLine ligne = lines.get(name);

			writer.write(txtseparator+ ligne.getName().replace(txtseparator, txtseparator+txtseparator)+ txtseparator + colseparator + ligne.getFrequency()); 

			if (partnames.size() > 1)

				for (int j = 0; j < partnames.size(); j++)

					writer.write(colseparator + ligne.getFrequency(j)); 

			writer.write("\n"); //$NON-NLS-1$

		}

		writer.flush();

		writer.close();

	}

	public List<String> getPartnames() {

		return partnames;

	}

	public QueryIndexLine addLine(String name, Query query) throws CqiClientException {

		if (lines.containsKey(name)) return null;

		QueryResult[] qresults;

		if (partition != null) {

			qresults = new QueryResult[partition.getNPart()];

			List<Part> parts = partition.getParts();

			for (int i = 0 ; i < parts.size() ; i++) {

				qresults[i] = parts.get(i).query(query, "tmp", true); //$NON-NLS-1$

				//qresults[i].drop(); // free mem done later

			}

		} else {

			qresults = new QueryResult[1];

			qresults[0] = corpus.query(query, "tmp", true); //$NON-NLS-1$

			//qresults[0].drop(); // free mem done later

		}

		QueryIndexLine line = new QueryIndexLine(name, query, qresults);

		lines.put(name, line);

		return line;

	}

	public LexicalTable toLexicalTable() {

		if (partition == null) return null;

		int npart = partition.getNPart();

		int[][] freqs = new int[lines.size()][npart];

		String[] rownames = new String[lines.size()];

		String[] colnames = new String[npart];

		int i = 0;

		for (String key : lines.keySet()) {

			QueryIndexLine line = lines.get(key);

			int[] linefreqs = line.getFreqs();

			rownames[i] = line.getName();

			for (int j = 0 ; j < npart ; j++) {

				freqs[i][j] = linefreqs[j];

			}

			i++;

		}

		List<Part> parts = partition.getParts();

		for (int j = 0 ; j < npart ; j++) {

			colnames[j] = parts.get(j).getName();

		}

		try {

			LexicalTableImpl lt = new LexicalTableImpl(freqs, rownames, colnames);

			LexicalTable table = new LexicalTable(partition, partition.getProperty(), 1, lt);

			return table;

		} catch (Exception e) {

			Log.printStackTrace(e);

		}

		return null;

	}

	public boolean removeLine(String name) {

		if (lines.containsKey(name)) {

			lines.remove(name);

			return true;

		} else {

			return false;

		}

	}

	public boolean hasLine(String name) {

		return lines.containsKey(name);

	}

	public ArrayList<QueryIndexLine> getLines(int from, int to) {

		if (lines.size() == 0) return new ArrayList<QueryIndexLine>();

		if (from < 0) from = 0;

		if (to < 0) to = 0;

		if (to > lines.size()) to = lines.size();

		if (from > to) from = to - 1;

		ArrayList<QueryIndexLine> tmp = new ArrayList<QueryIndexLine>();

		int i = 0;

		for (QueryIndexLine line : lines.values()) {

			if (i >= from && i < to) {

				tmp.add(line);

			}

			i++;

		}

		return tmp;

	}

	@Override

	public void clean() {

		try {

			this.writer.flush();

			this.writer.close();	

		} catch (IOException e) {

			Log.printStackTrace(e);

		}

	}

	@Override

	public Object getAdapter(Class adapterType) {

		if (adapterType == IWorkbenchAdapter.class)

			return queryindexAdapter;

		return null;

	}

	/** The QueryIndex adapter. */

	private static IWorkbenchAdapter queryindexAdapter = new IWorkbenchAdapter() {

		@Override

		public Object[] getChildren(Object o) {

			return new Object[0];

		}

		@Override

		public ImageDescriptor getImageDescriptor(Object object) {

			return IImageKeys.getImageDescriptor(IImageKeys.QUERYINDEX);

			//return AbstractUIPlugin.imageDescriptorFromPlugin("QueryIndexRCP", "icons/functions/WordCloud.png"); //$NON-NLS //$NON-NLS-1$

			//return null;

		}

		@Override

		public String getLabel(Object o) {

			return ((QueryIndex) o).getName();

		}

		@Override

		public Object getParent(Object o) {

			if (((QueryIndex) o).getPartition() != null) {

				return ((QueryIndex) o).getPartition();

			} else {

				return ((QueryIndex) o).getCorpus();

			}

		}

	};

	@Override

	public boolean delete() {

		if (partition != null) return partition.removeResult(this);

		else if (corpus != null) return corpus.removeResult(this);

		return false;

	}

	@Override

	public String getSimpleName() {

		return "";

	}

	@Override

	public String getDetails() {

		return "";

	}

}

<html>

<body>

<p>Prototype of Query index.</p>

</body>

</html>

package org.txm.functions.queryindex;

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

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

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

public class QueryIndexLine {

	String name;

	private Query query;

	QueryResult[] qresults;

	int[] freqs;

	int total;

	public QueryIndexLine(String name, Query query, QueryResult[] qresults) {

		this.qresults = qresults;

		this.query = query;

		this.name = name;

	}

	public String getName() {

		return name;

	}

	public Query getQuery() {

		return query;

	}

	public int[] getFreqs() {

		computeFreqsAndTotal();

		return freqs;

	}

	private void computeFreqsAndTotal() {

		if (freqs == null) {

			//System.out.println("compute freqs");

			total = 0;

			try {

				freqs = new int[qresults.length];

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

					//System.out.println("add "+qresults[i].getNMatch());

					freqs[i] = qresults[i].getNMatch();

					total += freqs[i];

					qresults[i].drop();

				}

				qresults = null;

			} catch (CqiClientException e) {

				// TODO Auto-generated catch block

				org.txm.utils.logger.Log.printStackTrace(e);

				freqs = new int[0];

			}

		} else {

			total = 0;

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

				total += freqs[i];

			}

		}

	}

	public int getFrequency() {

		computeFreqsAndTotal();

		return total;

	}

	public int getFrequency(int i) {

		computeFreqsAndTotal();

		return freqs[i];

	}

	public void setFrequencies(int[] freqs) {

		this.freqs = freqs;

//		total = 0 ;

//		for (int f : freqs) total+=f;

//		System.out.println("total : "+total);

	}

	/*private static void mergeMatches(int from, List<Match> matches, List<Match> tmp) {

		int im1 = 0;

		for (int im2 = 0 ; im2 < tmp.size() && im1 < matches.size() ;) {

			Match m1 = matches.get(im1);

			Match m2 = tmp.get(im2);

			if (m1.getStart() < m2.getStart()) {

				im1++;

			} else if (m1.getStart() >  m2.getStart()) {

				im2++;

				matches.add(im1,m2);

			} else {

				if (m1.getEnd() <  m2.getEnd()) {

					im1++;

				} else if (m1.getEnd() >  m2.getEnd()) {

					im2++;

					matches.add(im1,m2);

				} else {

					System.out.println("ERROR while merging : m1 == m2");

				}

			}

		} // end of match merge

	}

	public void union(List<QueryIndexLine> lines) throws CqiClientException {

		for (QueryIndexLine line : lines) { // process lines	

			for (QueryResult qresult : line.getQResult()) {

				List<Match> matches = qresult.getMatches();

				int nmatches = matches.size();

				int im1 = 0;

				List<Match> matches2 = qresult.getMatches();

				int nmatches2 = matches2.size();

				ArrayList<Match> tmp = new ArrayList<Match>(); // receive the match to add

				// 1-5 2-5 3-6 7-9

				// 1.4 1-5 2-5 3-5 7-8 7-9

				// select all without doublons

				int im2;

				for (im2 = 0 ; im2 < nmatches2 && im1 < nmatches ;) {

					Match m1 = matches.get(im1);

					Match m2 = matches2.get(im2);

					if (m1.getStart() == m2.getStart() && m1.getEnd() == m2.getEnd()) {

						// don't add

						im2++; // test next match2

					} else {

						tmp.add(m2);

						if (m1.getStart() <  m2.getStart()) {

							im1++;

						} else if (m1.getStart() >  m2.getStart()){

							im2++;

						} else {

							if (m1.getEnd() <  m2.getEnd()) {

								im1++;

							} else {

								im2++;

							} 

						}

					}

				} // almost end of match selection

				for (int i = im2 ; i < nmatches2 ; i++) 

					tmp.add(matches2.get(im2)); // get the last ones if any

				// merge

				mergeMatches(0, matches, tmp);

			} // end of union

			freqs = null; // will be recomputed next time

		}

	}*/

	/*public void inter(List<QueryIndexLine> lines) throws CqiClientException {

		List<Match> matches = qresult.getMatches();

		for (QueryIndexLine line : lines) {

			List<Match> matches2 = line.getQResult().getMatches();

		}

		freq = -1;

	}

	public void minus(List<QueryIndexLine> lines)throws CqiClientException {

		List<Match> matches = qresult.getMatches();

		for (QueryIndexLine line : lines) {

			List<Match> matches2 = line.getQResult().getMatches();

		}

		freq = -1;

	}

	 */

}

// Copyright © 2010-2013 ENS de Lyon.

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

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

// Sophia Antipolis, University of Paris 3.

// 

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

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

// License as published by the Free Software Foundation,

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

// later version.

// 

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

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

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

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

// details.

// 

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

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

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

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.rcpapplication.commands.function;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.handlers.HandlerUtil;

import org.txm.index.rcp.messages.IndexUIMessages;

import org.txm.rcp.StatusLine;

import org.txm.rcp.TXMWindows;

import org.txm.rcpapplication.editors.input.QueryIndexEditorInput;

import org.txm.rcpapplication.editors.queryindex.QueryIndexEditor;

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

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

import org.txm.utils.logger.Log;

// TODO: Auto-generated Javadoc

/**

 * open the Index Editor 

 * @author mdecorde.

 */

public class ComputeQueryIndex extends AbstractHandler {

	/** The ID. */

	public static String ID = "org.txm.rcpapplication.commands.function.ComputeQueryIndex"; //$NON-NLS-1$

	/** The selection. */

	private IStructuredSelection selection;

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		Log.info("Compute QueryIndex: start");

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

		Object s = selection.getFirstElement();

		if (s instanceof Corpus) {

			final Corpus corpus = (Corpus) s;

			openEditor(corpus);

		} else if (s instanceof Partition) {

			final Partition partition = (Partition) s;

			openEditor(partition);

		} else {

			Log.severe("Can not compute QueryIndex with: "+s);

		}

		return null;

	}

	public static void openEditor(Corpus corpus) {

		IWorkbenchPage page = TXMWindows.getActiveWindow().getActivePage();

		QueryIndexEditorInput editorInput = new QueryIndexEditorInput(corpus);

		try {

			StatusLine.setMessage(IndexUIMessages.ComputeIndex_0);

			QueryIndexEditor voceditor = (QueryIndexEditor) page

					.openEditor(editorInput,QueryIndexEditor.ID);

			voceditor.initializeFields();

		} catch (Exception e) {

			Log.printStackTrace(e);

		}

	}

	public static void openEditor(Partition partition) {

		IWorkbenchPage page = TXMWindows.getActiveWindow().getActivePage();

		QueryIndexEditorInput editorInput = new QueryIndexEditorInput(partition);

		try {

			StatusLine.setMessage(IndexUIMessages.ComputeIndex_0);

			QueryIndexEditor voceditor = (QueryIndexEditor) page

					.openEditor(editorInput, QueryIndexEditor.ID);

			voceditor.initializeFields();

		} catch (Exception e) {

			Log.printStackTrace(e);

		}

	}

}

// Copyright © 2010-2013 ENS de Lyon.

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

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

// Sophia Antipolis, University of Paris 3.

// 

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

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

// License as published by the Free Software Foundation,

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

// later version.

// 

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

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

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

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

// details.

// 

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

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

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

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.rcpapplication.commands.link;

import java.util.ArrayList;

import org.apache.batik.util.gui.CSSMediaPanel.Dialog;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.dialogs.ListSelectionDialog;

import org.eclipse.ui.handlers.HandlerUtil;

import org.txm.functions.queryindex.QueryIndex;

import org.txm.lexicaltable.core.functions.LexicalTable;

import org.txm.rcp.Messages;

import org.txm.rcp.StatusLine;

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

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

// TODO: Auto-generated Javadoc

/**

 * The Class IndexToLexicalTable.

 */

public class QueryIndexToLexicalTable extends AbstractHandler {

	/** The window. */

	private IWorkbenchWindow window;

	/** The selection. */

	private IStructuredSelection selection;

	private static Shell shell;

	/* (non-Javadoc)

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

	 */

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		// TODO Auto-generated method stub

		window = HandlerUtil.getActiveWorkbenchWindow(event);

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

		shell = HandlerUtil.getActiveWorkbenchWindowChecked(event)

		.getShell();

		return null;

	}

	/**

	 * Builds the lexical table.

	 *

	 * @param qindex the voc

	 * @param from the from

	 * @param to the to

	 * @return true, if successful

	 */

	public boolean buildLexicalTable(QueryIndex qindex, int from, int to) {

		LexicalTable table;

		Partition partition;

		Property property;

		if (!qindex.isComputedWithPartition()) {

			System.out.println(Messages.IndexToLexicalTable_0);

			StatusLine.setMessage(Messages.IndexToLexicalTable_0);

			return false;

		}

		System.out.println(Messages.ComputeLexicalTable_3);

		ArrayList<String> choices = new ArrayList<String>();

		choices.add(Messages.ComputeLexicalTable_16);

		choices.add(Messages.ComputeLexicalTable_12);

		ListSelectionDialog dialog = new ListSelectionDialog(shell, 

				choices, new ArrayContentProvider(), new LabelProvider(), 

				Messages.ComputeLexicalTable_13);

		int ret = dialog.open();

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

		if (ret == Dialog.OK_OPTION) {

		} else {

			return false;

		}

		// TODO: fix line 119

//		try {

//			table = LexicalTableImpl.createLexicalTableImpl(voc, QuantitativeDataStructureImpl

//					.createSymbole(LexicalTableImpl.class));

//			partition = voc.getPartition();

//			property = voc.getCorpus().getProperties().get(0);

//		} catch (Exception e) {

//			org.txm.rcpapplication.utils.Logger.printStackTrace(e);

//			return false;

//		}

//

//		try {

//			IWorkbenchWindow window = PlatformUI.getWorkbench()

//					.getActiveWorkbenchWindow();

//			IWorkbenchPage page = window.getActivePage();

//			LexicalTableEditorInput editorInput = new LexicalTableEditorInput(

//					table, partition, property);

//			StatusLine.setMessage(Messages.ComputeLexicalTable_10);

//			page

//					.openEditor(editorInput,

//							"org.txm.rcpapplication.editors.lexicaltable.LexicalTableEditor"); //$NON-NLS-1$

//		} catch (PartInitException e) {

//			org.txm.rcpapplication.utils.Logger.printStackTrace(e);

//		} 

		return false;

	}

}

<html>

<body>

	<p>Commands which create link between 2 textometry function</p>

</body>

</html>

// Copyright © 2010-2013 ENS de Lyon.

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

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

// Sophia Antipolis, University of Paris 3.

// 

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

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

// License as published by the Free Software Foundation,

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

// later version.

// 

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

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

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

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

// details.

// 

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

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

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

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.rcpapplication.editors.queryindex;

import java.util.List;

import org.eclipse.jface.viewers.IStructuredContentProvider;

import org.eclipse.jface.viewers.Viewer;

import org.txm.functions.queryindex.QueryIndexLine;

// TODO: Auto-generated Javadoc

/**

 * The IStructuredContentProvider used by the reference and line tables.

 *

 * @author jmague

 */

public class LineContentProvider implements IStructuredContentProvider {

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java

	 * .lang.Object)

	 */

	@Override

	public Object[] getElements(Object inputElement) {

		@SuppressWarnings("unchecked")

		List<QueryIndexLine> lines = (List<QueryIndexLine>) inputElement;

		return lines.toArray();

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.viewers.IContentProvider#dispose()

	 */

	@Override

	public void dispose() {

		// TODO Auto-generated method stub

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface

	 * .viewers.Viewer, java.lang.Object, java.lang.Object)

	 */

	@Override

	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

		// TODO Auto-generated method stub

	}

}

// Copyright © 2010-2013 ENS de Lyon.

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

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

// Sophia Antipolis, University of Paris 3.

// 

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

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

// License as published by the Free Software Foundation,

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

// later version.

// 

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

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

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

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

// details.

// 

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

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

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

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.rcpapplication.editors.queryindex;

import org.eclipse.jface.viewers.ILabelProviderListener;

import org.eclipse.jface.viewers.ITableLabelProvider;

import org.eclipse.swt.graphics.Image;

import org.txm.functions.queryindex.QueryIndexLine;

// TODO: Auto-generated Javadoc

/**

 * The Class LineLabelProvider.

 */

public class LineLabelProvider implements ITableLabelProvider {

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnImage(java.lang.Object, int)

	 */

	@Override

	public Image getColumnImage(Object element, int columnIndex) {

		return null;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnText(java.lang.Object, int)

	 */

	@Override

	public String getColumnText(Object element, int columnIndex) {

		QueryIndexLine line = (QueryIndexLine) element;

		switch (columnIndex) {

		case 0:

			return ""; //$NON-NLS-1$

		case 1:

			return line.getName();

		case 2:

			return "" + line.getFrequency(); //$NON-NLS-1$

		default:

			if (line.getFreqs().length > 1

					&& columnIndex - 3 < line.getFreqs().length)

				return "" + line.getFrequency(columnIndex - 3); //$NON-NLS-1$

			else

				return "";//$NON-NLS-1$

		}

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.IBaseLabelProvider#addListener(org.eclipse.jface.viewers.ILabelProviderListener)

	 */

	@Override

	public void addListener(ILabelProviderListener listener) {

		// TODO Auto-generated method stub

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.IBaseLabelProvider#dispose()

	 */

	@Override

	public void dispose() {

		// TODO Auto-generated method stub

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.IBaseLabelProvider#isLabelProperty(java.lang.Object, java.lang.String)

	 */

	@Override

	public boolean isLabelProperty(Object element, String property) {

		// TODO Auto-generated method stub

		return false;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.IBaseLabelProvider#removeListener(org.eclipse.jface.viewers.ILabelProviderListener)

	 */

	@Override

	public void removeListener(ILabelProviderListener listener) {

		// TODO Auto-generated method stub

	}

}

// Copyright © 2010-2013 ENS de Lyon.

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

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

// Sophia Antipolis, University of Paris 3.

// 

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

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

// License as published by the Free Software Foundation,

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

// later version.

// 

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

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

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

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

// details.

// 

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

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

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

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.rcpapplication.editors.queryindex;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.ScrolledComposite;

import org.eclipse.swt.events.ControlAdapter;

import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.events.KeyListener;

import org.eclipse.swt.events.MouseAdapter;

import org.eclipse.swt.events.MouseEvent;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.graphics.Font;

import org.eclipse.swt.graphics.FontData;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.layout.FormAttachment;

import org.eclipse.swt.layout.FormData;

import org.eclipse.swt.layout.FormLayout;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.FileDialog;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.Spinner;

import org.eclipse.swt.widgets.TableColumn;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.part.EditorPart;

import org.txm.functions.queryindex.QueryIndex;

import org.txm.functions.queryindex.QueryIndexLine;