Laboratoire ICAR » Plateforme TXM

	@Override

	public void widgetDefaultSelected(SelectionEvent e) {

		// TODO Auto-generated method stub

	}

	@Override

		fMin.setIncrement(1);

		fMin.setPageIncrement(100);

		fMin.addSelectionListener(computeSelectionListener);

		label = new Label(filtercontrols, SWT.NONE);

		label.setText(CooccurrenceUIMessages.CooccurrencesEditor_5);

		cMin.setIncrement(1);

		cMin.setPageIncrement(100);

		cMin.addSelectionListener(computeSelectionListener);

		label = new Label(filtercontrols, SWT.NONE);

		label.setText(CooccurrenceUIMessages.CooccurrencesEditor_6);

		minScore = new FloatSpinner(filtercontrols, SWT.BORDER);

		minScore.addKeyListener(computeKeyListener);

		// empant

		empantLayoutData.right = new FormAttachment(100);

		empantPanel.setLayoutData(empantLayoutData);

		empantPanel.addSelectionListener(computeSelectionListener);

		// result area

		Composite resultArea = this.getResultArea();

		// FIXME: became useless?

package org.txm.cooccurrence.rcp.editors;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.layout.GridData;

		checkLeft.removeSelectionListener(listener);

		checkRight.removeSelectionListener(listener);

	}

}

	@Override

	public void setDirty() {

		super.setDirty();

		this.setChartDirty();

	}

	@Override

	public void setNeedsFullRecomputing(boolean needsFullRecomputing) {

		super.setNeedsFullRecomputing(needsFullRecomputing);

	}

	@Override

	public boolean compute(IProgressMonitor monitor) {

		try {

			// compute the result if needed

			if(super.compute(monitor, true))	{

		this.subTask("Rendering chart for result " + this.getClass() + " and chart type " + this.getChartType() + ".");

		if (!this.chartDirty && !this.isChartDirtyFromHistory()) {

			return true;

		}

		else if (!this.chartDirty) {

			return true;

		}

				}

				chartCreator = ChartsEngine.getChartsEngines().get(i).getChartCreator(this);

				if(chartCreator != null)	{

					this.chartsEngine = ChartsEngine.getChartsEngines().get(i);

					break;

				}

			// - the chart has never been created

			// - the chart type has been changed, e.g. to dynamically change the type of chart or the current charts engine

			if (this.chart == null || this.hasParameterChanged(ChartsEnginePreferences.CHART_TYPE)) {

				this.chart = chartCreator.createChart(this);

			}

			this.updateDirty(previousValue, newValue);

			if (this.dirty) {

				// FIXME: debug

				return this.dirty; // no need to go further

			}

		}

	 * @return the current name

	 */

	public String getCurrentName() {

			return this.userName;

		}

			return this.lazyName;

		}

		else {

		try {

			// FIXME: see if this skipComputing tests is still useful? is it possible to directly return instead?

			// en fait voir ChartResult.compute() if(super.compute(monitor, true, false)), je pense que le prob vient du fait que si on retourne false dans TXMResult.compute() alors renderChart() ne sera pas appelé 

			boolean d1 = this.needsFullRecomputing; // FIXME: SJ: need to try again to stop to use this parameter

			boolean d2 = this.isDirtyFromHistory();

			boolean d3 = this.isDirty();

				// needsFullRecomputing == true && isDirtyFromHistory == true && isDirty == true

				skipComputing = true;

			}

			if(!skipComputing)	{

				// FIXME: Debug

				// TODO THIS IS FUCKING LAZY LINE CODES OH YEAH YOU MAD BRO

				// TODO where do we put this parent compute ? :o

	public boolean canCompute() {

		// null or empty queries

			Log.severe("Progression.canCompute(): can not compute with no query."); //$NON-NLS-1$

			return false;

		}

		// Fill the data set from the result

			XYSeriesCollection dataset = (XYSeriesCollection) chart.getXYPlot().getDataset();

			dataset.removeAllSeries();

	public static final double[] toDouble(REXP rexp) throws RWorkspaceException {

		try {

			return rexp.asDoubles();

			throw new RWorkspaceException(e);

		}

	}

		// try {

		// m = new

		// DenseDoubleMatrix2D(connection.eval(variableName).asDoubleMatrix());

		// // TODO Auto-generated catch block

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

		// } catch (RserveException e) {

	 * of column in every row.

	 * @throws RWorkspaceException the r workspace exception

	 */

		int ncol = 0;

		if (matrix.length == 0) {

			ncol = 0;

			ncol = matrix[0].length;

		}

		int nrow = matrix.length;

			} catch (RserveException e) {

				throw new RWorkspaceException(e);

			}

			comm.assign(variableName, vector, nrow, ncol);

		}

		Log.finest("MATRIX_ADDED_TO_WORKSPACE" + new Object[] { nrow, ncol, variableName }); //$NON-NLS-1$

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

		if (filecommunication) {

			comm.assign(variableName, vector);

			try {

				connection.assign(variableName, vector);

			} catch (REngineException e) {

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

		vector.trimToSize();

		double[] vald = vector.elements();

		if (filecommunication) {

			comm.assign(variableName, vald);

			try {

				connection.assign(variableName, vald);

			} catch (REngineException e) {

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

		//checkForDuplicateVariable(variableName);

		if (filecommunication) {

			comm.assign(variableName, vector);

			try {

				connection.assign(variableName, vector);

			} catch (REngineException e) {

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

		vector.trimToSize();

		int[] vald = vector.elements();

		if (filecommunication) {

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

		try {

			connection.assign(variableName, vector);

		} catch (RserveException e) {

			RWorkspace.printLastSafeEvalExpr();

			throw new RWorkspaceException(e);

			throw new RException(exp + "; " + e.getMessage(), e); //$NON-NLS-1$

		}

//		if(this.isLoggingEvalCommandLines())	{

		double[] res = null;

		try {

			res = eval(exp).asDoubles();

			throw new RWorkspaceException(e);

		}

		return res;

		double[][] res = null;

		try {

			res = eval(exp).asDoubleMatrix();

			throw new RWorkspaceException(e);

		}

		return res;

					res[j][i] = tmp[c++];

				}

			}

			throw new RWorkspaceException(e);

		}

		return res;

		String[] res = null;

		try {

			res = eval(exp).asStrings();

			throw new RWorkspaceException(e);

		}

		return res;

	 * @return the rEXP

	 * @throws RWorkspaceException the r workspace exception

	 */

		try {

			return list.asList().at(item_name);

			throw new RWorkspaceException(RCoreMessages.error_errorDuringItemsListExtraction

					+ e.getMessage()); 

		}

	 * @return the rEXP

	 * @throws RWorkspaceException the r workspace exception

	 */

		return eval(list_symbol + RConstant.LIST_EXTRACTOR + item_name);

	}

		}

		try {

			return res.asStrings();

			throw new RWorkspaceException(e);

		}

	}

	 * @param variableName the variable name

	 * @throws RWorkspaceException the r workspace exception

	 */

		try {

			connection.voidEval("rm(" + variableName + ")"); //$NON-NLS-1$ //$NON-NLS-2$

		} catch (RserveException e) {

	 * @throws RException the r exception

	 * @throws REXPMismatchException the rEXP mismatch exception

	 */

		if (logging && inputLogger != null ) inputLogger.printMessage(expr); //$NON-NLS-1$

		lastSafeevalExpr = expr;

				out =  "result: "+ret;

			}

		} catch (RserveException e) {

			System.out.println(NLS.bind(RCoreMessages.error_evaluationError, e.getMessage(), exp));

			Log.printStackTrace(e);

		}

		if(this.isLoggingEvalCommandLines())	{

			Log.finest("EVALUATED_EXPRESSION: " + exp ); //$NON-NLS-1$

		}

			safeEval(exp);

		} catch (RserveException e) {

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

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

		}

import org.jfree.chart.axis.SymbolAxis;

import org.jfree.chart.axis.ValueAxis;

import org.jfree.chart.labels.XYToolTipGenerator;

import org.jfree.chart.plot.CrosshairState;

import org.jfree.chart.plot.PlotRenderingInfo;

import org.jfree.chart.plot.XYPlot;

		this.multipleItemsSelector = new MultipleItemsSelector(this);

		this.multipleItemsSelector.setResult(result);

		this.chart = chart;

import java.util.Map;

import org.jfree.chart.ChartPanel;

import org.jfree.chart.event.RendererChangeEvent;

import org.txm.chartsengine.core.results.ChartResult;

import org.txm.chartsengine.jfreechart.core.renderers.interfaces.IRendererWithItemSelection;

import org.txm.chartsengine.jfreechart.core.themes.highcharts.defaulttheme.renderers.ItemSelectionXYLineAndShapeRenderer;

	 */

	public void setResult(ChartResult result) {

		this.result = result;

	}

	 * @return the chartPanel

	 */

	public ChartPanel getChartPanel() {

	}

import org.txm.chartsengine.rcp.editors.ChartEditor;

import org.txm.core.results.Parameter;

import org.txm.rcp.IImageKeys;

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

/**

		// Extend the chart editor tool bar

		new ToolItem(this.chartToolBar, SWT.SEPARATOR);

		// Number of clusters

	    CLabel clustersLabel = new CLabel(this.chartToolBar, SWT.CENTER);

		clustersLabel.setText(AHCUIMessages.toolbars_numberOfClusters);

	    this.numberOfClusters.setMinimum(2);

	    this.numberOfClusters.setIncrement(1);

	    this.chartToolBar.addControl(this.numberOfClusters);

		// Columns

		this.columnsComputing = new ToolItem(this.chartToolBar, SWT.RADIO);

		this.columnsComputing.setToolTipText(AHCUIMessages.tooltips_computeColumns);

		this.columnsComputing.setImage(IImageKeys.getImage(AHCChartEditor.class, "icons/compute_columns.png")); //$NON-NLS-1$

		// Rows

		this.rowsComputing = new ToolItem(this.chartToolBar, SWT.RADIO);

		this.rendering2D = new Button(this.chartToolBar, SWT.CHECK);

		this.rendering2D.setText("2D");//$NON-NLS-1$

		this.chartToolBar.addControl(this.rendering2D);

	}

			//voc.toTxt(new File("/home/mdecorde/TEMP/before.tsv"), "UTF-8", "\t", "");

			try {

				index.alterFrequencies(referenceCorpus);

				// TODO Auto-generated catch block

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

				return false;

			System.out.println("length ltnames: "+rw.eval("length(ltnames)").asInteger());

			System.out.println("ncol: "+rw.eval("ncol("+symbol+")").asInteger());

			System.out.println("nrow: "+rw.eval("nrow("+symbol+")").asInteger());

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	/**

	 * Creates the chart container component from the chart object stored into the composite.

	 */

	/**

	 * Disposes the editor.

	/**

	 * @return

	 */

	public String getChartType()	{

	 */

	public CAItemSelectionRenderer(CA ca, JFreeChart chart) {

		super(ca, chart);

	}

		Shape s;

		// visible shapes mode

		if(((CA) this.multipleItemsSelector.getResult()).isShowPointShapes())	{

			if(this.multipleItemsSelector.isMouseOverItem(series, item) || this.multipleItemsSelector.isSelectedItem(series, item)) {

				// Add a background rectangle to the label selected item

				// FIXME : not rounded rectangle version

//				Shape labelBackground = new Rectangle2D.Double(-bounds.getWidth() / 2, -s.getBounds2D().getHeight() / 2 + 1, bounds.getWidth() + 4, bounds.getHeight() / 2 + 8);

				AffineTransform t = new AffineTransform();

				labelBackground = t.createTransformedShape(labelBackground);

				Area a = new Area(s);

			}

		}

		else	{

			String label = ((CAXYDataset) this.getPlot().getDataset()).getLabel(series, item);

			s = new RoundRectangle2D.Double(-(bounds.getWidth()) / 2, -bounds.getHeight() / 2, bounds.getWidth(), bounds.getHeight() - 2 , 5, 5);

			// Highlight selected item

				// Arrays.sort(rowdist);

			} catch (RWorkspaceException e) {

				throw new StatException(CACoreMessages.error_failedToGetContributionColumn + e.getMessage(), e);

				// TODO Auto-generated catch block

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

			}

				// Arrays.sort(rowdist);

			} catch (RWorkspaceException e) {

				throw new StatException(CACoreMessages.error_failedToGetCos2Column + e.getMessage(), e);

				// TODO Auto-generated catch block

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

			}

				// Arrays.sort(rowdist);

			} catch (RWorkspaceException e) {

				throw new StatException(CACoreMessages.error_failedToGetConstributionRow + e.getMessage(), e);

				// TODO Auto-generated catch block

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

			}

				// Arrays.sort(rowdist);

			} catch (RWorkspaceException e) {

				throw new StatException(CACoreMessages.error_failedToGetCos2Row + e.getMessage(), e);

				// TODO Auto-generated catch block

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

			}

		double[][] res;

		try {

			res = r.asDoubleMatrix();

			throw new StatException(SpecificitiesCoreMessages.ComputeError_FAILED_TO_GET_SPECIFICITIES + e.getMessage(), e);

		}

		Log.finest((res.length * res[0].length) + SpecificitiesCoreMessages.Specificites_2);