Laboratoire ICAR » Plateforme TXM

			return;

		}

		if (lastValue == null || !lastValue.equals(newValue)) {

			this.setDirty();

		}

	}

			Object newValue = f.get(this);

			this.updateDirty(previousValue, newValue);

			if (this.dirty) {

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

			}

		}

	protected boolean compute(IProgressMonitor monitor, boolean deepComputing) {

		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 skipComputing = false;

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

			//		if (parent != null && !parent.getHasBeenComputedOnce()) { // parent must be computed at least one time

			// SJ: other way, test the object itself

			if (this.parent != null && !(this.parent instanceof Project)) {

				if (!this.parent.compute(monitor, true)) {

					Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": failed to compute parent result.");

				}

			}

			boolean d2 = this.isDirtyFromHistory();

			boolean d3 = this.isDirty();

					!d2 && !d3) {

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

				Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": result parameters have not changed since last computing, computing skipped.");

				// FIXME: Debug

				Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": computing result of type " + this.getClass() + "...");

				// Computing requirements test

				if (!this.canCompute()) {

					return false;

				}

			// clear the lazy name, no more needed since the object has been computed and getSimpleName() can now work

			this.lazyName = null;

			if(!skipComputing)	{

				// store last used parameters

				// Children cascade computing ; if parent == null this is the Workspace

				if (deepComputing && parent != null) {

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

						// FIXME: may be better to add a member needFullRecomputing in TXMResult?

//					this.getChild(i).setDirty(); // force recomputing even if some parameters of the result itself have not changed

						this.children.get(i).setNeedsFullRecomputing(true); // force recomputing even if some parameters of the result itself have not changed

						// recompute only children that has been opened once

						//}

					}

					// here for tests purpose

//				for (TXMResult child : this.getChildren()) {

//					child.setNeedsFullRecomputing(true); // force recomputing even if some parameters of the result itself have not changed

	}

	@Override

		// TODO Auto-generated method stub

		return false;

	}

		}

	}

	/**

	 * Renders the chart using the right chart creator.

	 * The chart is created if needed then it is updated.

		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.chartDirty = false;

			// Debug

			return true;

		}

		else	{

			return false;

		}

	}

	@Override

	public String dumpParameters() {

		return super.dumpParameters() + "\n" + this.dumpParameters(Parameter.RENDERING); //$NON-NLS-1$

	}

			Object newValue = f.get(this);

			this.updateChartDirty(previousValue, newValue);

			if (this.chartDirty) {

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

			}

		}

			return;

		}

		if (lastValue == null || !lastValue.equals(newValue)) {

			this.chartDirty = true;

		}

	}

public class SpecificitiesSelection extends ChartResult {

	/**

	 * Banality threshold.

	 */

	@Parameter(key=SpecificitiesPreferences.CHART_BANALITY, type=Parameter.RENDERING)

	/**

	 * To draw bars or not.

	 */

	@Parameter(key=SpecificitiesPreferences.CHART_DRAW_BARS, type=Parameter.RENDERING)

	/**

	 * To draw lines or not.

	 */

	@Parameter(key=SpecificitiesPreferences.CHART_DRAW_LINES, type=Parameter.RENDERING)

	/**

	 * Group by lines / transpose matrix.

	 */

	@Parameter(key=SpecificitiesPreferences.CHART_GROUP_BY_LINES, type=Parameter.RENDERING)

	/**

	 * The selected type names to focus on.

	 */

	@Parameter(key=SpecificitiesPreferences.VALUES, type=Parameter.RENDERING)

	/**

	 * @param parametersNodePath

	 */

	public SpecificitiesSelection(String parametersNodePath)	{

	}

	@Override

	protected boolean _compute() throws Exception {

		double[][] tableLines = specificities.getSpecificitesIndex();

		String[] partNames = specificities.getPartShortNames();

		String[] rowNames = specificities.getTypeNames();

		int n = 0;

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

			double[] line = tableLines[i];

			String rowName = rowNames[i];

				selectedSpecificitiesIndex[n++] = line;

			}

		}

	 * @return the banality

	 */

	public float getBanality() {

	}

	@Override

		StringBuilder sb = new StringBuilder();

		sb.append(this.getName());

		}

		}

		}

		}

		return sb.toString();

	}

	@Override

	public String getName() {

		if (name.length() > 80) {

			name = name.substring(0, 79) + "...";

		}

	 * @return the selectedTypeNames

	 */

	public List<String> getSelectedTypeNames() {

	}

	@Override

	 * @return the drawBars

	 */

	public boolean isDrawingBars() {

	}

	/**

	 * @return the drawLines

	 */

	public boolean isDrawingLines() {

	}

	/**

	 * @return the groupByLines

	 */

	public boolean isGroupingByLines() {

	}

	@Override

	public boolean loadParameters() {

		String str = this.getStringParameterValue(SpecificitiesPreferences.VALUES);

		if (!str.isEmpty()) {

		}

		return true;

	}

	@Override

	public boolean saveParameters() {

		}

		return true;

	}

	 * @param banality the banality to set

	 */

	public void setBanality(float banality) {

	}

	/**

	 * @param groupByLines the groupByLines to set

	 */

	public void setGroupByLines(boolean groupByLines) {

	}

	@Override

	 * @param selectedTypeNames the selectedTypeNames to set

	 */

	public void setSelectedTypeNames(List<String> selectedTypeNames) {

	}

	@Override

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

		// TODO Auto-generated method stub

		return false;

	}

}

		try {

			// Query:

			// make

			miniInfoLabel = new Label(getMainParametersComposite(), SWT.NONE);

			miniInfoLabel.setText(ProgressionUIMessages.ProgressionEditor_no_query);

			miniInfoLabel.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, false, false));

			cumulativeButton = new Button(paramPanel, SWT.RADIO);

			cumulativeButton.setText(ProgressionUIMessages.ProgressionDialog_2);

			// listeners

				@Override

				public void widgetSelected(SelectionEvent e) {

					bandeField.setEnabled(densityButton.getSelection());

					getResult().setDefaultChartType();

				}

			});

			densityButton = new Button(paramPanel, SWT.RADIO);

			densityButton.setText(ProgressionUIMessages.ProgressionDialog_3);

			// listener

				@Override

				public void widgetSelected(SelectionEvent e) {

					bandeField.setEnabled(densityButton.getSelection());

				}

			});

			// Bande size

			propertyRegex = new Text(structuration, SWT.SINGLE | SWT.BORDER);

			// FIXME: layout

			//propertyRegex.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true, 2, 1));

			// Repeat same values in part markers

			repeatSameValues = new Button(paramPanel, SWT.CHECK);

			repeatSameValues.setText(ProgressionUIMessages.ProgressionDialog_15);

			// Lines styles

			multipleLineStrokes = new Button(paramPanel, SWT.CHECK);

			multipleLineStrokes.setText(SWTComponentsProviderMessages.preferences_multipleLineStrokeStyles);

			// Queries

	private Listener tableResizeListener;

	/** The query widget. */

	@Parameter(key=ConcordancePreferences.QUERY)

	protected AssistedQueryWidget queryWidget;

	@Override

	public void init(IEditorSite site, IEditorInput input) throws PartInitException {

		super.init(site, input);

		viewer2.getControl().setRedraw(true);

	}

	/**

	 * Get the Composite that contains the query and sort forms

	 * 

	public void updateResultFromEditor() {

		// TODO

	}

}

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;

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

import org.txm.specificities.core.functions.SpecificitiesSelection;

	@Override

	public void __createPartControl() {

		// Group bars by lines

		groupBarsByLines = new ToolItem(this.getToolBar(), SWT.CHECK);

		groupBarsByLines.setToolTipText(SpecificitiesUIMessages.SpecificitiesPreferencePage_4);

		groupBarsByLines.setImage(IImageKeys.getImage(ComputeSpecifities.class, "icons/silk_group_bars_by_lines.png"));

		// Banality

		banality = new FloatSpinner(this.getExtendedParametersComposite(), SWT.BORDER);

		banality.setToolTipText("Banality threshold");

	}

import java.awt.BasicStroke;

import java.awt.Color;

import java.text.DecimalFormat;

import java.util.ArrayList;

import java.util.TreeMap;

import org.jfree.chart.ChartFactory;

import org.jfree.chart.labels.ItemLabelPosition;

import org.jfree.chart.plot.PlotOrientation;

import org.jfree.chart.plot.XYPlot;

import org.jfree.ui.TextAnchor;

import org.txm.ca.core.chartsengine.base.CAChartCreator;

import org.txm.ca.core.chartsengine.base.Utils;

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

import org.txm.chartsengine.jfreechart.core.JFCChartCreator;

import org.txm.chartsengine.jfreechart.core.renderers.MultipleItemsSelector;

import org.txm.statsengine.core.StatException;

import org.txm.utils.logger.Log;

		try {

			CAXYDataset dataset = new CAXYDataset(ca);

			chart = ChartFactory.createScatterPlot(Utils.createCAFactorialMapChartTitle(ca), 

					"", "", dataset, PlotOrientation.VERTICAL, 

					CAPreferences.getInstance().getBoolean(ChartsEnginePreferences.SHOW_LEGEND), false, false);

		// freeze rendering while computing

		chart.setNotify(false);

		CAItemSelectionRenderer renderer = (CAItemSelectionRenderer) chart.getXYPlot().getRenderer(); 

		renderer.setSeriesVisible(0, ca.isShowVariables());

		renderer.setSeriesVisible(1, ca.isShowIndividuals());

        	renderer.setBasePositiveItemLabelPosition(position);

        	renderer.setBaseNegativeItemLabelPosition(position);

        }

        // Draw only the item labels

        else	{

        	colsColor = new Color(colsColor.getRed(), colsColor.getGreen(), colsColor.getBlue(), 235);

            renderer.setSeriesItemLabelPaint(0, rowsColor);

            renderer.setSeriesItemLabelPaint(1, colsColor);

        	// Labels position

        	ItemLabelPosition position = new ItemLabelPosition(ItemLabelAnchor.CENTER, TextAnchor.CENTER, TextAnchor.CENTER, 0.0);

        	renderer.setBasePositiveItemLabelPosition(position);

        	renderer.setBaseNegativeItemLabelPosition(position);

            renderer.setItemLabelAnchorOffset(0);

        }

		super.updateChart(result);

    	// FIXME

    //	this.getChartsEngine().squareOffGraph((JFreeChart) chart, 200, 200d);

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

			Font font = this.getItemLabelFont(series, item);

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

			// Highlight selected item

			String refPropertyNames = this.getStringParameterValue(ConcordancePreferences.VIEW_REFERENCE_PATTERN);

			if ("*".equals(refPropertyNames)) {

				if (refProperty == null) {

					this.pViewRefPattern = new ReferencePattern(sup_textid);

				} else {

					this.pViewRefPattern = new ReferencePattern(refProperty);

				}

			} else {

			}

			refPropertyNames = this.getStringParameterValue(ConcordancePreferences.ANALYSIS_REFERENCE_PATTERN);

			if ("*".equals(refPropertyNames)) { //$NON-NLS-1$

				Property refProperty = getCorpus().getProperty("ref");//$NON-NLS-1$

				if (refProperty == null) {

					this.pAnalysisRefPattern = new ReferencePattern(sup_textid);

				} else {

					this.pAnalysisRefPattern = new ReferencePattern(refProperty);

	protected boolean _compute() throws Exception {

		if (pQueryResult != null) {

			this.queryResult = pQueryResult;

			this.queryResult = this.getCorpus().query(pQuery, pQuery.getQueryString().replace(" ", "_") + "_concordance", true); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		}

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.HashMap;

import org.txm.searchengine.cqp.MemCqiClient;

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

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

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

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

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

	}

	@Override

			}

		}

	}

	@Override

	}

	@Override

		// TODO Auto-generated method stub

		return false;

	}

	}

	@Override

		System.out.println("ExpII.compute(monitor): not implemented.");

		return false;

	}

	};

	@Override

		System.out.println("ExpI.compute(monitor): not implemented.");

		return false;

	}