Laboratoire ICAR » Plateforme TXM

	public boolean isResultUsingParent(TXMResult parent) {

		return this.concordance.getParent().getName().equals(parent.getName());

	}

	@Override

	@Override

	public boolean isResultUsingParent(TXMResult parent) {

		if (this.getResultData() == null) {

			return false;

		}

		if (this.getResultData().getCorpus() == null) {

			return false;

		}

		return this.getResultData().getCorpus().getName().equals(parent.getName());

	}

import org.eclipse.core.runtime.IProgressMonitor;

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.Subcorpus;

import org.txm.statsengine.core.StatException;

	public boolean setParameters(TXMParameters parameters) {

		return false;

	}

import org.txm.lexicaltable.rcp.editors.LexicalTableEditor2;

		if (editor instanceof LexicalTableEditor2) {

			LexicalTableEditor2 LTeditor = (LexicalTableEditor2) editor;

	public static void deleteLexicalTableLines(LexicalTableEditor2 LTeditor) {

import org.txm.lexicaltable.rcp.editors.LexicalTableEditor2;

		if (editor instanceof LexicalTableEditor2) {

			LexicalTableEditor2 LTeditor = (LexicalTableEditor2) editor;

import org.txm.lexicaltable.rcp.editors.LexicalTableEditor2;

		if (editor instanceof LexicalTableEditor2) {

			LexicalTableEditor2 LTeditor = (LexicalTableEditor2) editor;

import org.txm.lexicaltable.rcp.editors.LexicalTableEditor2;

import org.txm.lexicaltable.rcp.editors.LexicalTableEditorInput;

import org.txm.statsengine.r.core.data.QuantitativeDataStructureImpl;

import org.txm.utils.logger.Log;

		window = HandlerUtil.getActiveWorkbenchWindow(event);

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

		Object s = selection.getFirstElement();

		if (s instanceof Index) {

			List<Index> vocabularies = selection.toList();

				if(dialog.getResult().length == 0)

				if(sel.equals(RCPMessages.ComputeLexicalTable_16))

			computeWithVocabularies(vocabularies, useAllOccurrences);

			return null;

		} else if (s instanceof Partition) {

			computeWithPartition((Partition) s);

			return null;

		} else if (s instanceof LexicalTable) {

			computeWithLexicalTableAble((LexicalTable) s);

			return null;

		} else

			return null;

	}

	/**

	 * Compute with partition.

	 *

	 * @param partition the partition

	 */

	private void computeWithLexicalTableAble(final LexicalTable lexicalTableAble) {

		JobHandler jobhandler = new JobHandler(

				RCPMessages.ComputeLexicalTable_0) {

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				this.runInit(monitor);

				try {

					JobsTimer.start();

					monitor.beginTask(NLS.bind(RCPMessages.ComputeLexicalTable_1, lexicalTableAble.getName(), "none"), 100);

					this.acquireSemaphore();

					//table = lexicalTableAble.toLexicalTable();

					table = lexicalTableAble;

					this.releaseSemaphore();

					monitor.worked(45);

					lexicalTableAble.getParent().addChild(table);

					monitor.worked(5);

					//monitor.subTask(Messages.ComputeSpecifities_10);

					syncExec(new Runnable() {

						@Override

						public void run() {

							IWorkbenchPage page = window.getActivePage();

							LexicalTableEditorInput editorInput = new LexicalTableEditorInput(table);

							try {

								StatusLine.setMessage(RCPMessages.ComputeLexicalTable_10);

								page.openEditor(editorInput, LexicalTableEditor2.ID);

							} catch (PartInitException e) {

								org.txm.rcp.utils.Logger.printStackTrace(e);

							} 

						}

					});

					monitor.worked(50);

					if (monitor.isCanceled())

						return Status.CANCEL_STATUS;

					//monitor.subTask(Messages.ComputeSpecifities_2);

					syncExec(new Runnable() {

						@Override

						public void run() {

							CorporaView.refresh();

							CorporaView.expand(table.getParent());

							QueriesView.refresh();

							RVariablesView.refresh();

						}

					});

					monitor.worked(100);

				} catch (ThreadDeath td) {

					return Status.CANCEL_STATUS;

				} catch (Exception e) {

					org.txm.rcp.utils.Logger.printStackTrace(e);

				} finally {

					monitor.done();

					JobsTimer.stopAndPrint();

				}

				return Status.OK_STATUS;

		};

		jobhandler.startJob();

		return;

	}

	/**

	 * Compute with partition.

	 *

	 * @param partition the partition

	 */

	private void computeWithPartition(final Partition partition) {

		final Property property;

		final int Fmin;

		final int vmax;

		String title = RCPMessages.bind(RCPMessages.ComputeLexicalTable_0, partition.getName());

		LexicalTableDialog d = new LexicalTableDialog(window.getShell(), partition.getCorpus(), title);

		d.setFminAndVMax(TXMPreferences.getInt(LexicalTablePreferences.F_MIN, LexicalTablePreferences.PREFERENCES_NODE), 

						TXMPreferences.getInt(LexicalTablePreferences.V_MAX, LexicalTablePreferences.PREFERENCES_NODE));

		if (d.open() == Window.OK) {

			property = d.getProperty();

			Fmin = d.getFmin();

			vmax = d.getMaxLines();

			// PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().findView(CorporaView.ID);

			JobHandler jobhandler = new JobHandler(

					RCPMessages.bind(RCPMessages.ComputeLexicalTable_0, partition.getName())) {

				@Override

				protected IStatus run(IProgressMonitor monitor) {

					this.runInit(monitor);

					try {

						JobsTimer.start();

						monitor.beginTask(NLS.bind(RCPMessages.ComputeLexicalTable_1, partition.getName(), property), 100);

						this.acquireSemaphore();

						table = LexicalTableFactory.getLexicalTable(partition, property, Fmin);

						this.releaseSemaphore();

						this.acquireSemaphore();

						table.getData().cut(vmax);

						this.releaseSemaphore();

						monitor.worked(45);

						if (monitor.isCanceled() || table == null) {

							return Status.CANCEL_STATUS;

						}

						partition.addChild(table);

						monitor.worked(5);

						//monitor.subTask(Messages.ComputeSpecifities_10);

						syncExec(new Runnable() {

							@Override

							public void run() {

								IWorkbenchPage page = window.getActivePage();

								LexicalTableEditorInput editorInput = new LexicalTableEditorInput(table);

								try {

									StatusLine.setMessage(RCPMessages.ComputeLexicalTable_10);

									page.openEditor(editorInput, LexicalTableEditor2.ID); //$NON-NLS-1$

								} catch (PartInitException e) {

									org.txm.rcp.utils.Logger.printStackTrace(e);

								} 

							}

						});

						monitor.worked(50);

						if (monitor.isCanceled())

							return Status.CANCEL_STATUS;

						//monitor.subTask(Messages.ComputeSpecifities_2);

						syncExec(new Runnable() {

							@Override

							public void run() {

								QueriesView.refresh();

								RVariablesView.refresh();

							}

						});

						monitor.worked(100);

					} catch (ThreadDeath td) {

						return Status.CANCEL_STATUS;

					} catch (Exception e) {

						org.txm.rcp.utils.Logger.printStackTrace(e);

					} finally {

						monitor.done();

						JobsTimer.stopAndPrint();

					}

					return Status.OK_STATUS;

				}

			};

			jobhandler.startJob();

		}

		return;

	}

	/**

	 * Compute with vocabularies.

	 *

	 * @param fullvocabularies the fullvocabularies

	 * @return true, if successful

	 */

	private boolean computeWithVocabularies(List<Index> fullvocabularies, final boolean useAllOccurrences) {

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

			return false;

		}

		final List<Index> vocabularies = fullvocabularies.subList(0, 1);

		for (Index voc : vocabularies) {

			if (!voc.isComputedWithPartition()) {

				System.out.println(RCPMessages.ComputeLexicalTable_5);

				StatusLine.setMessage(RCPMessages.ComputeLexicalTable_5);

				return false;

			}

		}

		List<Property> properties = vocabularies.get(0).getProperties();

		for (Index voc : vocabularies) {

			if (!properties.equals(voc.getProperties())) {

				Log.warning(NLS.bind(RCPMessages.ComputeLexicalTable_6, properties));

				return false;

			}

		}

		final Index firstIndex = vocabularies.get(0);

		Partition firstPartition = firstIndex.getPartition();

		for (Index voc : vocabularies) {

			if (!firstPartition.equals(voc.getPartition())) {

				Log.warning(NLS.bind(RCPMessages.ComputeLexicalTable_7, firstPartition));

				return false;

			}

		}

		final Property property = properties.get(0);

		JobHandler jobhandler = new JobHandler(RCPMessages.bind(RCPMessages.ComputeLexicalTable_0, firstIndex.getName())) {

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				this.runInit(monitor);

				try {

					monitor.beginTask("Computing Lexical table with Index: "+firstIndex+" property: "+property, 100);

					this.acquireSemaphore();

					table = new LexicalTable(firstIndex);

					table.setParameters(null, null, null, useAllOccurrences);

					table.compute(true, monitor);

					monitor.worked(45);

					this.releaseSemaphore();

					if (monitor.isCanceled() || table == null)

						return Status.CANCEL_STATUS;

					firstIndex.addChild(table);

					monitor.worked(5);

					monitor.subTask(RCPMessages.ComputeLexicalTable_10);

					syncExec(new Runnable() {

						@Override

						public void run() {

							IWorkbenchPage page = window.getActivePage();

							LexicalTableEditorInput editorInput = new LexicalTableEditorInput(table);

							try {

								StatusLine.setMessage(RCPMessages.ComputeLexicalTable_10);

								page.openEditor(editorInput,

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

							} catch (PartInitException e) {

								org.txm.rcp.utils.Logger.printStackTrace(e);

							} 

						}

					});

					monitor.worked(50);

					if (monitor.isCanceled())

						return Status.CANCEL_STATUS;

					monitor.subTask(RCPMessages.ComputeSpecifities_2);

					syncExec(new Runnable() {

						@Override

						public void run() {

							CorporaView.refresh();

							CorporaView.expand(table.getParent());

							QueriesView.refresh();

							RVariablesView.refresh();

						}

					});

					monitor.worked(100);

				} catch (ThreadDeath td) { 

					return Status.CANCEL_STATUS;

				} catch (Exception e) {

					org.txm.rcp.utils.Logger.printStackTrace(e);

				} finally {

					monitor.done();

				}

				return Status.OK_STATUS;

			}

		};

		jobhandler.startJob();

		return true;

	}

import org.txm.lexicaltable.rcp.editors.LexicalTableEditor2;

		if (editor instanceof LexicalTableEditor2) {

			LexicalTableEditor2 LTeditor = (LexicalTableEditor2) editor;

	static public void mergeLines(LexicalTableEditor2 LTeditor, String newname,

import org.txm.lexicaltable.rcp.editors.LexicalTableEditor2;

		if (editor instanceof LexicalTableEditor2) {

			LexicalTableEditor2 LTeditor = (LexicalTableEditor2) editor;

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

import java.util.ArrayList;

import java.util.List;

import org.eclipse.jface.viewers.IStructuredContentProvider;

import org.eclipse.jface.viewers.ITableLabelProvider;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.graphics.Image;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.part.EditorPart;

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

import org.txm.rcp.editors.TXMResultEditorInput;

import org.txm.rcp.RCPMessages;

import org.txm.rcp.editors.Tablable;

import org.txm.rcp.editors.input.AbstractTablable;

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

import org.txm.statsengine.core.StatException;

// TODO: Auto-generated Javadoc

/**

 * The Class LexicalTableEditorInput.

 *

 * @author sloiseau

 */

public class LexicalTableEditorInput extends TXMResultEditorInput {

	/** The editors. */

	private List<EditorPart> editors;

	/** The inputs. */

	private List<IEditorInput> inputs;

	/**

	 * Instantiates a new lexical table editor input.

	 *

	 * @param table the table

	 * @param partition the partition

	 * @param property the property

	 */

	public LexicalTableEditorInput(final LexicalTable table) {

		super(table);

		editors = new ArrayList<EditorPart>();

		editors.add(new TableEditor());

		inputs = new ArrayList<IEditorInput>();

		class LexicalTableLabelProvider extends LabelProvider implements

				ITableLabelProvider {

			@Override

			public Image getColumnImage(Object element, int columnIndex) {

				return null;

			}

			@Override

			public String getColumnText(Object element, int columnIndex) {

				int[] val = (int[]) element;

				return String.valueOf(val[columnIndex]);

			}

		}

		Tablable asTable = new AbstractTablable() {

			@Override

			public String[] getColumnTitles() {

				return new String[] { RCPMessages.FrequencyListEditorInput_3,

						RCPMessages.FrequencyListEditorInput_4 };

			}

			@Override

			public String[] getColumnTypes() {

				return new String[] { RCPMessages.FrequencyListEditorInput_5,

						RCPMessages.FrequencyListEditorInput_6 };

			}

			@Override

			public IStructuredContentProvider getContentProvider() {

				return new IStructuredContentProvider() {

					@Override

					public Object[] getElements(Object inputElement) {

						LexicalTable res = (LexicalTable) inputElement;

						List<int[]> row = new ArrayList<int[]>();

						for (int i = 0; i < res.getNRows(); i++) {

							int[] v = null;

							try {

								v = res.getRow(i).asIntArray();

							} catch (StatException e) {

								System.err.println(NLS.bind(

										RCPMessages.GraphicalLogger_0, e));

							}

							row.add(v);

						}

						return row.toArray();

					}

					@Override

					public void dispose() {

						// TODO Auto-generated method stub

					}

					@Override

					public void inputChanged(Viewer viewer, Object oldInput,

							Object newInput) {

						// TODO Auto-generated method stub

					}

				};

			}

			@Override

			public Object getInput() {

				return table;

			}

			@Override

			public LabelProvider getLabelProvider() {

				return new LexicalTableLabelProvider();

			}

		};

		inputs.add(asTable);

	}

	/**

	 * Gets the lexical table.

	 *

	 * @return the lexicon

	 */

	public LexicalTable getLexicalTable() {

		return (LexicalTable) this.result;

	}

	/**

	 * Gets the property.

	 *

	 * @return the property

	 */

	public Property getProperty() {

		return this.getLexicalTable().getProperty();

	}

}

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

import java.io.File;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.jface.viewers.CellLabelProvider;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TableViewerColumn;

import org.eclipse.jface.viewers.ViewerCell;

import org.eclipse.jface.window.Window;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

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.Label;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.MessageBox;

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.core.results.TXMResult;

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

import org.txm.lexicaltable.core.statsengine.data.ILexicalTable;

import org.txm.lexicaltable.rcp.handlers.MergeLines;

import org.txm.lexicaltable.rcp.messages.LexicalTableUIMessages;

import org.txm.rcp.RCPMessages;

import org.txm.rcp.StatusLine;

import org.txm.rcp.editors.TXMEditorPart;

import org.txm.rcp.editors.TableKeyListener;

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

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

import org.txm.statsengine.core.StatException;

import org.txm.statsengine.core.data.Vector;

/**

 * display the lexical table tools to merge/delete lines or columns and display

 * the lexical table too

 * 

 * @author mdecorde

 */

public class LexicalTableEditor2 extends TXMEditorPart	{

	public static final String ID = LexicalTableEditor2.class.getName();

	/** The table. */

	LexicalTable table;

	ILexicalTable itable;

	// params

	/** The line table viewer. */

	TableViewer viewer;

	/** The form column. */

	TableViewerColumn formColumn;

	/** The freq column. */

	TableViewerColumn freqColumn;

	// org.eclipse.swt.widgets.List colCombo;

	/** The minfreqspinner. */

	Spinner minfreqspinner;

	/** The top spinner. */

	Spinner nLinesSpinner;

	/** The cols. */

	private List<double[]> cols;

	/** The rows. */

	private List<String> rows;

	/** The collist. */

	List<Object> collist;

	/** The freqs. */

	//private List<Integer> freqs;

	/** The previous sorted col. */

	private int previousSortedCol;

	boolean DEFAULTREVERSE = false;

	boolean reverse = DEFAULTREVERSE;

	/**

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

		super.init(site, input);

		table = ((LexicalTableEditorInput) input).getLexicalTable();

		itable = table.getData();

	}

	/**

	 * Sort.

	 *

	 * @param col the col

	 * @param index the index

	 */

	public void sort(TableViewerColumn col, int index) {

		if (index == previousSortedCol) {

			reverse = !reverse;

		} else {

			reverse = DEFAULTREVERSE;

		}

		if (index == -2) {// rownames

			itable.sortRowNames(reverse);

		} else if (index == -1) { // freqs

			try {

				itable.sortByFreqs(reverse);

				StatusLine.setMessage(RCPMessages.SORT_DONE);

			} catch (Exception e2) {

				org.txm.rcp.utils.Logger.printStackTrace(e2);

			}

		} else if (index >= 0) {

			itable.sort(index, reverse);

		}

		previousSortedCol = index;

		refreshTable();

		viewer.getTable().setSortColumn(col.getColumn());

		if (reverse)

			viewer.getTable().setSortDirection(SWT.DOWN);

		else

			viewer.getTable().setSortDirection(SWT.UP);

	}

	/**

	 * Creates the part control.

	 *

	 * @param parent the parent

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

	 */

	@Override

	public void createPartControl(final Composite parent) {

		super.createPartControl(parent);

		Composite paramArea = new Composite(this.getCommandParametersGroup(), SWT.NONE);

		GridLayout paramLayout = new GridLayout(5, false);

		paramArea.setLayout(paramLayout);

		// Apply button

		Button keepTop = new Button(paramArea, SWT.PUSH);

		keepTop.setText(LexicalTableUIMessages.LexicalTableEditor_4);

		keepTop.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				StatusLine.setMessage(LexicalTableUIMessages.LexicalTableEditor_16);

				System.out.println(NLS.bind(LexicalTableUIMessages.LexicalTableEditor_5, nLinesSpinner.getSelection(), minfreqspinner.getSelection()));

				MessageBox messageBox = new MessageBox(e.display.getActiveShell(), SWT.ICON_QUESTION | SWT.YES | SWT.NO);

				messageBox.setMessage(RCPMessages.DeleteLines_1);

				int response = messageBox.open();

				if (response != SWT.YES)

					return;

				try {

					itable.filter(nLinesSpinner.getSelection(), minfreqspinner.getSelection());

					refresh();

					StatusLine.setMessage(""); //$NON-NLS-1$

				} catch (Exception e1) {