Laboratoire ICAR » Plateforme TXM

				compute(true);

			TXMEditorPart.openEditor(cooc, CooccurrencesEditor.ID);

			return true;

			return false;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Spinner;

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

		groupBarsByLines.setSelection(this.getResultData().isGroupingByLines());

				getResultData().setGroupByLines(groupBarsByLines.getSelection());

		// Banality

        Label label = new Label(this.getCommandParametersGroup(), SWT.NONE);

        label.setText("Banality:");

		final Spinner banality = new Spinner(this.getCommandParametersGroup(), SWT.BORDER);

		int nbDigits = 1;

		banality.setToolTipText("Banality threshold");

		banality.setDigits(nbDigits);

		banality.setIncrement(1);

		banality.setMinimum(0);

		banality.setMaximum(200);

		banality.setSelection(((int) (getResultData().getBanality() * Math.pow(10, nbDigits))));

		banality.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				getResultData().setBanality(getSpinnerFloatSelection(banality));

				compute(true);

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) {

				// does nothing

			}

		});

	@Override

	public SpecificitiesSelection getResultData() {

		return (SpecificitiesSelection) super.getResultData();

	}

 * @author sjacquot

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

	protected Spinner maxScore;

		this.maxScore = new Spinner(parametersArea, SWT.BORDER);

		this.maxScore.setToolTipText("The maximum score to show");

		this.maxScore.setMinimum(0);

		this.maxScore.setSelection(this.getResultData().getMaxScore());

		return (Specificities) super.getResultData();

		this.getResultData().setMaxScore(this.maxScore.getSelection());

import org.eclipse.swt.widgets.Spinner;

	/**

	 * Computes the result stored in the specified editor input and opens an editor specified by its id.

	 * @param editorInput

	 * @param editorPartId

	 * @return

	 */

	public static void openEditor(TXMResultEditorInput editorInput, String editorPartId)	{

		compute(editorInput, editorPartId, false, null);

	}

	/**

	 * Computes specified result stored, creates an editor input and opens an editor specified by its id.

	 * @param result

	 * @param editorPartId

	 * @return

	 */

	public static void openEditor(TXMResult result, String editorPartId)	{

		openEditor(new TXMResultEditorInput(result), editorPartId);

	}

		compute(update, this);

	public static void compute(final boolean update, final TXMEditorPart editor)	{

		compute(editor.getEditorInput(), null, update, editor);

	public static void compute(final TXMResultEditorInput editorInput, final String editorId, final boolean update, final TXMEditorPart editor)	{

		StatusLine.setMessage("Computing " + editorInput.getResult().getName());

			TXMEditorPart currentEditor = null;

		    		currentEditor = editor;

//		    		if (currentEditor != null)	{

//		    			currentEditor.updateResultFromEditor();

					editorInput.getResult().compute(update, monitor);

//					if (!editorInput.getResult().compute(update, monitor))	{

					monitor.worked(50);

					// opening an editor if not exists

					if (currentEditor == null)	{

						this.syncExec(new Runnable() {

							@Override

							public void run() {

								try {

									Log.info("TXMEditorPart.compute(): opening editor with id " + editorId);

									IWorkbenchWindow window =TXMWindows.getActiveWindow();

									IWorkbenchPage page = window.getActivePage();

									currentEditor = (TXMEditorPart) page.openEditor(editorInput, editorId, true, IWorkbenchPage.MATCH_INPUT | IWorkbenchPage.MATCH_ID);

								} catch (Exception e) {

									System.err.println("TXMEditorPart.compute(): could not open editor: " + e.getLocalizedMessage());

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

								}

							}

						});

					}

					if (currentEditor != null)	{

								currentEditor.refresh(update);

	 * It should be called or called itself in the UI thread when accessing Widget parameters.

	 * Dedicated to dynamically change the editor components from the stored result.

	/**

	 * Returns the spinner value as float.

	 * @param spinner

	 * @return

	 */

	public static float getSpinnerFloatSelection(Spinner spinner)	{

		return (float) (spinner.getSelection() / Math.pow(10, spinner.getDigits()));

	}

	protected HashMap<String, Object> lastComputingParameters = new HashMap<String, Object>();

	protected void updateLastComputingParameters() throws Exception {

			Parameter parameter = f.getAnnotation(Parameter.class);

			if (parameter == null || parameter.type() != Parameter.COMPUTING) {

			lastComputingParameters.put(name, f.get(this));

			Parameter parameter = f.getAnnotation(Parameter.class);

			if (parameter == null || parameter.type() != Parameter.COMPUTING) {

			Object previousValue = lastComputingParameters.get(name);

			System.err.println("TXMResult.compute(): result parameters have not changed since last computing, computing skipped.");

		// SJ: other way, test the object itself

		// 		if (parent != null && !this.getHasBeenComputedOnce()) { 

		this.updateLastComputingParameters(); // store last used parameters

	public final int COMPUTING = 0, RENDERING = 1;  

	public int type() default Parameter.COMPUTING;

import org.txm.rcp.editors.TXMEditorPart;

		ChartEditorPart.openEditor(partitionDimensions, partitionDimensions.getClass().getName());

		this.addField(new BooleanFieldEditor(PartitionDimensionsPreferences.CHART_DIMENSIONS_SORT_BY_SIZE, PartitionUIMessages.PreferencesPage_DIMENSIONS_SORT_BY_PARTS_SIZE, chartsTab));

		this.addField(new BooleanFieldEditor(PartitionDimensionsPreferences.CHART_DIMENSIONS_DISPLAY_PARTS_COUNT_IN_TITLE, PartitionUIMessages.PreferencesPage_DIMENSIONS_DISPLAY_PARTS_COUNT_IN_TITLE, chartsTab));

		sortByPartSize.setSelection(this.getResultData().isSortingBySize());

				getResultData().setSortBySize(sortByPartSize.getSelection());

	@Override

	public PartitionDimensions getResultData() {

		// TODO Auto-generated method stub

		return (PartitionDimensions) super.getResultData();

	}

	// FIXME: this method is not in use anymore since the editor opening is now down in TXMEditorPart so the code for ChartEngine downgrading is not 

	// active anymore. Try to use again this code

import org.txm.core.results.TXMResult;

import org.txm.rcp.editors.TXMResultEditorInput;

//	public static ChartEditorPart openEditor(ChartResult result) {

//		return openEditor(result, SWTChartsComponentsProvider.getCurrent());

//	}

	public static void openEditor(ChartResult result) {

		openEditor(result, result.getClass().getName());

	public static void openEditor(ChartResult result, String editorPartId)	{

		compute(new ChartEditorInput(result), editorPartId, false, null);

	}

	public static void openEditor(ChartResult result, SWTChartsComponentsProvider chartsComponentsProvider) {

		compute(new ChartEditorInput(result), result.getClass().getName(), false, null);

		//return chartsComponentsProvider.openEditor(result);

	public static final String CHART_DIMENSIONS_DISPLAY_PARTS_COUNT_IN_TITLE = PREFERENCES_PREFIX + "chart_dimensions_display_parts_count_in_title"; //$NON-NLS-1$

	public static final String CHART_DIMENSIONS_SORT_BY_SIZE = PREFERENCES_PREFIX + "chart_dimensions_sort_by_parts_size"; //$NON-NLS-1$

		preferences.putBoolean(CHART_DIMENSIONS_DISPLAY_PARTS_COUNT_IN_TITLE, true);

		preferences.putBoolean(CHART_DIMENSIONS_SORT_BY_SIZE, false);

	/**

	 * Parent partition parts caching.

	 */

	protected List<Part> parts = null;

	 * Parent partition parts sorted by size caching.

	 */

	protected List<Part> partsSortedBySize = null;

	@Parameter(type=Parameter.RENDERING)

	protected boolean displayPartCountInTitle;

	@Parameter(type=Parameter.RENDERING)

	protected boolean sortBySize;

	/**

		this.loadParameters();

	public boolean loadParameters() {

		this.displayPartCountInTitle = this.getBooleanParameterValue(PartitionDimensionsPreferences.CHART_DIMENSIONS_DISPLAY_PARTS_COUNT_IN_TITLE);

		this.sortBySize = this.getBooleanParameterValue(PartitionDimensionsPreferences.CHART_DIMENSIONS_SORT_BY_SIZE);

		return true;

	}

	@Override

		// parts

		this.parts = this.getPartition().getParts();

		// parts sorted by size 

		List<Part> sortedParts = new ArrayList<Part>(this.parts);

		Collections.sort(sortedParts, new Comparator<Part>() {

			@Override

			public int compare(Part arg0, Part arg1) {

				try {

					return arg1.getSize() - arg0.getSize();

				} catch (CqiClientException e) {

					return 0;

				}

			}

		});

		this.partsSortedBySize = sortedParts;

			this.setSortBySize((boolean)parameters.get(PartitionDimensionsPreferences.CHART_DIMENSIONS_SORT_BY_SIZE));

		return this.parts.size();

			return this.partsSortedBySize;

			return this.parts;

	/**

	 * @return the sortBySize

	 */

	public boolean isSortingBySize() {

		return sortBySize;

	}

	/**

	 * @param sortBySize the sortBySize to set

	 */

	public void setSortBySize(boolean sortBySize) {

		this.sortBySize = sortBySize;

	}

	/**

	 * @return the displayPartCountInTitle

	 */

	public boolean isDisplayingPartCountInTitle() {

		return displayPartCountInTitle;

	}

			boolean sortPartsBySize = partitionDimensions.isSortingBySize();

			boolean displayPartsCountInTitle = partitionDimensions.isDisplayingPartCountInTitle();

import org.txm.core.results.TXMResult;

			boolean sortPartsBySize = partitionDimensions.isSortingBySize();

			boolean displayPartsCountInTitle = partitionDimensions.isDisplayingPartCountInTitle();

import org.txm.core.results.TXMResult;

		boolean sortPartsBySize = partitionDimensions.isSortingBySize();

		boolean displayPartsCountInTitle = partitionDimensions.isDisplayingPartCountInTitle();

import org.jfree.chart.axis.SymbolAxis;

		boolean sortPartsBySize = partitionDimensions.isSortingBySize();

		boolean displayPartsCountInTitle = partitionDimensions.isDisplayingPartCountInTitle();

                used += findMaximumTickLabelWidth(ticks, g2, plotArea, isVerticalTickLabels());

                used = findMaximumTickLabelWidth(ticks, g2, plotArea, isVerticalTickLabels());

                used = findMaximumTickLabelHeight(ticks, g2, plotArea, isVerticalTickLabels());

                used = findMaximumTickLabelHeight(ticks, g2, plotArea, isVerticalTickLabels());

    protected List refreshTicksHorizontal(Graphics2D g2, Rectangle2D dataArea, RectangleEdge edge) {

import java.lang.reflect.Field;

import java.util.HashMap;

import org.txm.core.results.Parameter;

import org.txm.utils.logger.Log;

	/**

	 * To keep track of the parameters used for the last computing and to determine if the chart result is dirty. 

	 */

	protected HashMap<String, Object> lastRenderingParameters = new HashMap<String, Object>();

	/**

	 * If true, the view will be reset when the chart will be updated.

	 */

	/**

	 * If true, the items selection will cleared when the chart will be updated.

	 */

//		System.err.println("ChartResult.compute(): computing result of type " + this.getClass() + "...");

//

		// compute the result if needed

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

			// compute the chart

			return renderChart(update);

			return false;

	protected boolean renderChart(boolean update) throws Exception {

		this.subTask("rendering chart");

		System.err.println("ChartResult.renderChart(): rendering chart of type " + this.getClass() + "...");

		if (!this.isChartDirtyFromHistory()) {

			// FIXME: Debug

			System.err.println("ChartResult.renderChart(): chart rendering parameters have not changed since last rendering, rendering skipped.");

			return true;

		}

		else if(!this.chartDirty)	{

			System.err.println("ChartResult.renderChart(): chart is not dirty, rendering skipped.");

			return true;

				System.err.println("ChartResult.renderChart(): updating chart.");

				System.err.println("ChartResult.renderChart(): creating chart.");

			this.updateLastRenderingParameters();

			this.needsToClearItemsSelection = false;

			this.needsToResetView = false;

	/**

	 * Updates the parameters used for last rendering.

	 * @throws Exception

	 */

	protected void updateLastRenderingParameters() throws Exception {

		Field[] fields = this.getClass().getDeclaredFields();

		for (Field f : fields) {

			String name = f.getName();

			Parameter parameter = f.getAnnotation(Parameter.class);

			if (parameter == null || parameter.type() != Parameter.RENDERING) {

				continue;

			}

			f.setAccessible(true);

			this.lastRenderingParameters.put(name, f.get(this));

		}

	}

	public final boolean isChartDirtyFromHistory() throws Exception {

		Class clazz = this.getClass();

		Field[] fields = clazz.getDeclaredFields();

		for (Field f : fields) {

			String name = f.getName();

			Parameter annotation = f.getAnnotation(Parameter.class);

			if (annotation == null || annotation.type() != Parameter.RENDERING) {

				continue;

			}

			f.setAccessible(true); // not to set accessible to test the field values

			Object previousValue = this.lastRenderingParameters.get(name);

			Object newValue = f.get(this);

			this.updateChartDirty(previousValue, newValue);

			if (this.chartDirty) {

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

			}

		}

		return this.chartDirty;

	}

	/**

	 * Updates the chart dirty state by comparing an old parameter with a new one.

	 * 

	 * @param previousValue may be null

	 * @param newValue may be null

	 */

	protected void updateChartDirty(Object previousValue, Object newValue) {

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

			Log.info("Setting chart dirty to true: old = "+ previousValue + " / new = " + newValue);

			this.chartDirty = true;

		}

	}

			Log.finest(TXMCoreMessages.bind(TXMCoreMessages.SUBCORPUS_SIZE, new Object[]{this.name, "N/A"}));

			long start = System.currentTimeMillis();

				}

				else {

					int[] match = cqiClient.dumpSubCorpus(getQualifiedCqpId(), NetCqiClient.CQI_CONST_FIELD_MATCH, 0, nMatch - 1);

					int[] matchend = cqiClient.dumpSubCorpus(getQualifiedCqpId(), NetCqiClient.CQI_CONST_FIELD_MATCHEND, 0, nMatch - 1);

					if (match.length != matchend.length) {

					}

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

					}

			long end = System.currentTimeMillis();

			Log.finest(NLS.bind(TXMCoreMessages.END_SUBCORPUS_SIZE, new Object[]{this.name, this.size, (end - start)})); //$NON-NLS-1$

			// FIXME: old code

			//ChartEditorPart.compute(ca);

			// FIXME: new code

			ca.compute(false);

	protected int maxScore;

		this.maxScore = maxScore;

					.asList(lexicalTable.getRowNames().asStringsArray()), Arrays.asList(lexicalTable.getColNames().asStringsArray()), lexicalTable.getProperty().getName(), this.maxScore); 

					"TLNONAME: " + lexicalTable.getProperty().getName(), this.maxScore); //$NON-NLS-1$

		this.maxScore = maxScore;

	/**

	 * @return the maxScore

	 */

	public int getMaxScore() {

		return maxScore;