Laboratoire ICAR » Plateforme TXM

import org.txm.queryindex.core.functions.QueryIndex;

package org.txm.queryindex.core.functions;

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;

	}

	 */

}

package org.txm.queryindex.core.functions;

import org.eclipse.osgi.util.NLS;

import org.txm.utils.messages.Utf8NLS;

/**

 * QueryIndex messages.

 * 

 * @author mdecorde

 * @author sjacquot

 *

 */

public class Messages extends NLS {

	private static final String BUNDLE_NAME = "org.txm.queryindex.core.functions.messages"; //$NON-NLS-1$

	public static String QueryIndexEditor_0;

	public static String QueryIndexEditor_1;

	public static String QueryIndexEditor_10;

	public static String QueryIndexEditor_11;

	public static String QueryIndexEditor_2;

	public static String QueryIndexEditor_3;

	public static String QueryIndexEditor_4;

	public static String QueryIndexEditor_6;

	public static String QueryIndexEditor_7;

	public static String QueryIndexEditor_8;

	public static String QueryIndexEditor_9;

	static {

		// initialize resource bundle

		Utf8NLS.initializeMessages(BUNDLE_NAME, Messages.class);

	}

	private Messages() {

	}

}

QueryIndexEditor_0  = Index de requête de : 

QueryIndexEditor_1  = remplacement des lignes : 

QueryIndexEditor_10 = requêtes

QueryIndexEditor_11 = 

QueryIndexEditor_2  = Erreur lors de l'ajout de la requête : 

QueryIndexEditor_3  = Requête ajoutée

QueryIndexEditor_4  = Chargement depuis un fichier

QueryIndexEditor_6  = Le fichier suivant ne peut être lu : 

QueryIndexEditor_7  = Vers les concordances

QueryIndexEditor_8  = Vers la progression

QueryIndexEditor_9  = Supprimer les lignes

package org.txm.queryindex.core.functions;

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.core.runtime.IProgressMonitor;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.ui.model.IWorkbenchAdapter;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.core.results.TXMParameters;

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

		super(corpus);

		this.corpus = corpus;

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

	}

	public String getName() {

		if (partition != null)

			return partition.getName();

		return corpus.getName();

	}

	public QueryIndex(Partition partition) {

		super(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, this.getV(), 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 "";

	}

	@Override

	public boolean canCompute() {

		return corpus != null || partition != null;

	}

	@Override

	public boolean _compute() throws Exception {

		//FIXME: not yet implemented

		System.err.println("QueryIndex.compute(): not yet implemented.");

		return false;

	}

	@Override

	public boolean saveParameters() throws Exception {

		//FIXME: not yet implemented

		System.err.println("QueryIndex.saveParameters(): not yet implemented.");

		return false;

	}

	@Override

	public boolean loadParameters() throws Exception {

		//FIXME: not yet implemented

		System.err.println("QueryIndex.loadParameters(): not yet implemented.");

		return false;

	}

	@Override

	public boolean setParameters(TXMParameters parameters) throws Exception {

		//FIXME: not yet implemented

		System.err.println("QueryIndex.setParameters(): not yet implemented.");

		return false;

	}

	@Override

	public String getResultype() {

		return "Query index";

	}

}

<html>

<body>

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

</body>

</html>

QueryIndexEditor_0  = Query Index of

QueryIndexEditor_1  = replacing line:

QueryIndexEditor_10 = queries

QueryIndexEditor_11 = 

QueryIndexEditor_2  = Failed to add line with query:

QueryIndexEditor_3  = Line added.

QueryIndexEditor_4  = Load from a file

QueryIndexEditor_6  = Cannot read from file:

QueryIndexEditor_7  = Link to concordance

QueryIndexEditor_8  = Link to progression

QueryIndexEditor_9  = delete lines

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

import java.util.List;

import org.eclipse.jface.viewers.IStructuredContentProvider;

import org.eclipse.jface.viewers.Viewer;

import org.txm.queryindex.core.functions.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.queryindex.rcp.editors.queryindex;

import org.eclipse.jface.viewers.ILabelProviderListener;

import org.eclipse.jface.viewers.ITableLabelProvider;

import org.eclipse.swt.graphics.Image;

import org.txm.queryindex.core.functions.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.queryindex.rcp.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.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.Point;

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.txm.core.messages.TXMCoreMessages;

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

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

import org.txm.queryindex.core.functions.Messages;

import org.txm.queryindex.core.functions.QueryIndex;

import org.txm.queryindex.core.functions.QueryIndexLine;

import org.txm.queryindex.rcp.editors.input.QueryIndexEditorInput;

import org.txm.rcp.JobsTimer;

import org.txm.rcp.StatusLine;

import org.txm.rcp.editors.TXMEditor;

import org.txm.rcp.editors.TableKeyListener;

import org.txm.rcp.messages.TXMUIMessages;

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

import org.txm.rcp.swt.widget.NamedAssistedQueryWidget;

import org.txm.rcp.swt.widget.NavigationWidget;

import org.txm.rcp.utils.JobHandler;

import org.txm.rcp.views.QueriesView;

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

import org.txm.searchengine.cqp.CQPSearchEngine;

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

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

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

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

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

import org.txm.statsengine.r.rcp.views.RVariablesView;

import org.txm.utils.logger.Log;

/**

 * display the query index parameters and result.

 * 

 * @author mdecorde

 */

public class QueryIndexEditor extends TXMEditor<QueryIndex> {

	/** The Constant ID. */

	public static final String ID = "org.txm.rcp.editors.queryindex.QueryIndexEditor"; //$NON-NLS-1$

	/** The corpus. */

	protected Corpus corpus;

	protected Partition partition; // can be null

	/** The index. */

	protected QueryIndex queryindex;

	boolean stored = false; // start storing at first line added

	// protected boolean saveQueryIndex = true;

	// params

	/** The query label. */

	protected Label queryLabel;

	/** The query widget. */

	protected NamedAssistedQueryWidget queryWidget;

	/** The N ligne p page spinner. */

	protected Spinner NLignePPageSpinner;

	// infos

	/** The navigation area. */

	protected NavigationWidget navigationArea;

	/** The l fmin info. */

	protected Label lFminInfo;

	/** The l fmax info. */

	protected Label lFmaxInfo;

	/** The l v info. */

	protected Label lVInfo;

	/** The l t info. */

	protected Label lTInfo;

	// result

	/** The line table viewer. */

	protected TableViewer viewer;

	/** The n column. */

	protected TableColumn nColumn;

	/** The unit column. */

	protected TableColumn unitColumn;

	/** The freq column. */

	protected TableColumn freqColumn;

	/** The separator column. */

	protected TableColumn separatorColumn;

	/** The top line. */

	protected int topLine;

	/** The bottom line. */

	protected int bottomLine;

	/** The nblinesperpage. */

	protected int nblinesperpage;

	/** The nblinesmax. */

	protected int nblinesmax;

//	/** The scroll composite. */

//	private ScrolledComposite scrollComposite;

//

//	/** The head composite. */

//	private Composite headComposite;

	/** The title. */

	String title;

	/**

	 * Instantiates a new index editor.

	 */

	public QueryIndexEditor() {

		super();

	}

	/**

	 * Do save.

	 * 

	 * @param arg0

	 *            the arg0

	 * @see org.eclipse.ui.part.EditorPart#doSave(org.eclipse.core.runtime.IProgressMonitor)

	 */

	@Override

	public void doSave(IProgressMonitor arg0) {

		// TODO Auto-generated method stub

	}

	/**

	 * Do save as.

	 * 

	 * @see org.eclipse.lyon gournd zeroui.part.EditorPart#doSaveAs()

	 */

	@Override

	public void doSaveAs() {

		// TODO Auto-generated method stub

	}

	/**

	 * Inits the.

	 * 

	 * @param site

	 *            the site

	 * @param input

	 *            the input

	 * @throws PartInitException

	 *             the part init exception

	 * @see org.eclipse.ui.part.EditorPart#init(org.eclipse.ui.IEditorSite,

	 *      org.eclipse.ui.IEditorInput)

	 */

	@Override

	public void init(IEditorSite site, IEditorInput input)

			throws PartInitException {

		setSite(site);

		setInput(input);

		this.corpus = ((QueryIndexEditorInput) input).getCorpus();

		this.partition = ((QueryIndexEditorInput) input).getPartition();

		this.queryindex = ((QueryIndexEditorInput) input).getQueryIndex();

	}

	/**

	 * Checks if is dirty.

	 * 

	 * @return true, if is dirty

	 * @see org.eclipse.ui.part.EditorPart#isDirty()

	 */

	@Override

	public boolean isDirty() {

		return false;

	}

	/**

	 * Checks if is save as allowed.

	 * 

	 * @return true, if is save as allowed

	 * @see org.eclipse.ui.part.EditorPart#isSaveAsAllowed()

	 */

	@Override

	public boolean isSaveAsAllowed() {

		return false;

	}

	private QueryIndex createQueryIndex() {

		if (queryindex == null) {

			if (partition != null) {

				queryindex = new QueryIndex(partition);

				title = Messages.QueryIndexEditor_0 + partition.getName();

			} else {

				queryindex = new QueryIndex(corpus);

				title = Messages.QueryIndexEditor_0 + corpus;

			}

		}

		return queryindex;

	}

	/**

	 * Compute index.

	 */

	public void compute() {

		createQueryIndex();

		StatusLine.setMessage(IndexUIMessages.IndexEditor_33);

		final Query query; // if the query is empty then we put "[]" instead

		if (!queryWidget.getQueryString().equals("\"\"")) {//$NON-NLS-1$

			query = new Query(queryWidget.getQueryString());

		} else {

			System.err.println(IndexUIMessages.IndexEditor_0);

			return;

		}

		final String name;

		if (queryWidget.getQueryName().length() == 0) {

			name = query.toString();

		} else {

			name = queryWidget.getQueryName();

		}

		try {

			JobHandler jobhandler = new JobHandler(title,

					queryWidget.getParent()) {

				@Override

				protected IStatus run(IProgressMonitor monitor) {

					this.runInit(monitor);

					JobsTimer.start();

					final QueryIndexLine line;

					try {

						try {

							if (queryindex.hasLine(name)) {

								System.out.println(Messages.QueryIndexEditor_1 + name);

								queryindex.removeLine(name);

							}

							line = queryindex.addLine(name, query);

						} catch (CqiClientException e2) {

							System.out

									.println(Messages.QueryIndexEditor_2

											+ query);

							Log.printStackTrace(e2);

							return Status.CANCEL_STATUS;

						}

						if (line == null) {

							System.out

									.println(Messages.QueryIndexEditor_2

											+ query);

							return Status.CANCEL_STATUS;

						}

						if (monitor.isCanceled())

							return Status.CANCEL_STATUS;

						queryindex.sortLines(SortMode.FREQUNIT, true);

						if (monitor.isCanceled())

							return Status.CANCEL_STATUS;

						this.acquireSemaphore();

						this.releaseSemaphore();

						final String message = Messages.QueryIndexEditor_3;

						if (monitor.isCanceled())

							return Status.CANCEL_STATUS;

						monitor.worked(95);

						// refresh ui

						syncExec(new Runnable() {

							@Override

							public void run() {

								System.out.println(message);

								StatusLine.setMessage(message);

								CorporaView.refresh();

								CorporaView.expand(queryindex.getParent());

								QueriesView.refresh();

								RVariablesView.refresh();

								setPartName(title);

								queryWidget.memorize();

								nblinesperpage = NLignePPageSpinner

										.getSelection();

								fillDisplayArea(0,

										NLignePPageSpinner.getSelection());

								if (line != null) {

									queryWidget.setText(""); //$NON-NLS-1$

									queryWidget.setName(""); //$NON-NLS-1$

									queryWidget.focus();

								}

							}

						});

					} catch (Exception e) {

						System.out.println(e.getLocalizedMessage());

						try {

							System.out.println(TXMUIMessages.LastCQPError

									+ CQPSearchEngine.getCqiClient().getLastCQPError());

						} catch (Exception e1) {

							System.out.println(IndexUIMessages.IndexEditor_10

									+ e1);

							Log.printStackTrace(e1);

						}

						Log.severe("Error while computing QueryIndex: "+e.getLocalizedMessage());

					} catch (ThreadDeath td) {

						return Status.CANCEL_STATUS;

					} finally {

						monitor.done();

						JobsTimer.stopAndPrint();

					}

					return Status.OK_STATUS;

				}

			};

			jobhandler.startJob();

		} catch (Exception e1) {

			Log.printStackTrace(e1);

		}

	}

	/**

	 * Creates the part control.

	 * 

	 * @param parent

	 *            the parent

	 * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite)

	 */

	@Override

	public void _createPartControl() {

		// create scrollable area

//		scrollComposite = new ScrolledComposite(parent, SWT.H_SCROLL | SWT.NONE);

//		FormData headLayoutData = new FormData();

//		headLayoutData.top = new FormAttachment(0, 0);

//		headLayoutData.left = new FormAttachment(0);

//		headLayoutData.right = new FormAttachment(100);

//		scrollComposite.setLayoutData(headLayoutData);

//		scrollComposite.setLayout(new FormLayout());

//

//		headComposite = new Composite(scrollComposite, SWT.NONE);

//		headLayoutData = new FormData();

//		headLayoutData.top = new FormAttachment(0);

//		headLayoutData.bottom = new FormAttachment(100);

//		headLayoutData.left = new FormAttachment(0);

//		headLayoutData.right = new FormAttachment(100);

//		headComposite.setLayoutData(headLayoutData);

//		headComposite.setLayout(new FormLayout());

//

//		scrollComposite.setContent(headComposite);

//		scrollComposite.setExpandVertical(true);

//		scrollComposite.setExpandHorizontal(true);

//		scrollComposite.addControlListener(new ControlAdapter() {

//			@Override

//			public void controlResized(ControlEvent e) {

//				Rectangle r = scrollComposite.getClientArea();

//				scrollComposite.setMinSize(headComposite.computeSize(

//						SWT.DEFAULT, SWT.DEFAULT));

//			}

//		});

		final Composite paramArea = getExtendedParametersComposite();

		// info&navigation panel

		// final Composite infosArea = new Composite(headComposite, SWT.NONE);

		// FormData infosLayoutData = new FormData();

		// infosLayoutData.top = new FormAttachment(paramArea, 0);

		// infosLayoutData.left = new FormAttachment(0);

		// infosLayoutData.right = new FormAttachment(100);

		// infosArea.setLayoutData(infosLayoutData);

		Composite resultArea = getResultArea();

		// compose paramArea

		FormLayout paramLayout = new FormLayout();

		paramArea.setLayout(paramLayout);

		// on créé une Query, ici le pivot de la concordance est "[]"

		// Query Area: query itself + view properties

		Composite queryArea = new Composite(paramArea, SWT.NONE);

		FormData queryLayoutData = new FormData();

		queryLayoutData.top = new FormAttachment(0);

		queryLayoutData.left = new FormAttachment(0);

		queryLayoutData.right = new FormAttachment(100);

		queryArea.setLayoutData(queryLayoutData);

		queryArea.setLayout(new GridLayout(4, false));

		// | Query: [ (v)] [Search] |

		// Query:

		// queryLabel = new Label(queryArea, SWT.NONE);

		// queryLabel.setText(RCPMessages.IndexEditor_3);

		// queryLabel.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false,

		// true));

		// [ (v)]

		queryWidget = new NamedAssistedQueryWidget(queryArea, SWT.DROP_DOWN,

				this.corpus);

		GridData layoutData = new GridData(GridData.VERTICAL_ALIGN_CENTER);

		layoutData.horizontalAlignment = GridData.FILL;

		layoutData.grabExcessHorizontalSpace = true;

		queryWidget.setLayoutData(layoutData);

		queryWidget.addKeyListener(new KeyListener() {

			@Override

			public void keyPressed(KeyEvent e) {

				// System.out.println("key pressed : "+e.keyCode);

				if (e.keyCode == SWT.CR || e.keyCode == SWT.KEYPAD_CR) {

					compute();

				}

			}

			@Override

			public void keyReleased(KeyEvent e) {

			}

		});

		Button loadFromFile = new Button(queryArea, SWT.BOLD);

		loadFromFile.setEnabled(true);

		loadFromFile.setText(Messages.QueryIndexEditor_4);

		loadFromFile

				.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_CENTER));

		loadFromFile.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				File propFile = null;

				if (LastOpened.getFile(ID) != null)

					propFile = new File(LastOpened.getFolder(ID));

				FileDialog dialog = new FileDialog(getShell(), SWT.OPEN);

				String[] exts = { "*.properties" }; //$NON-NLS

				dialog.setFilterExtensions(exts);

				if (propFile != null) {

					dialog.setFilterPath(propFile.getParent());

					dialog.setFileName(propFile.getName());

				}

				String path = dialog.open();

				if (path != null) {

					propFile = new File(path);

					// compute();

					// System.out.println("TODO: load from file "+propFile);