Laboratoire ICAR » Plateforme TXM

	@Override

	public boolean loadParameters() {

		String s = this.getStringParameterValue(IndexPreferences.PROPERTIES);

		this.pProperties = WordProperty.fromStringToList(getCorpus(), s);

		this.pQuery = new Query(this.getStringParameterValue(IndexPreferences.QUERY));

		return true;

	}

	 */

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

	/**

	 * Creates a new TXMResult, child of the specified parent.

	 * 

		// + this.preferencesNodeQualifier + ", class = " + getClass());

		this.dirty = true;

		// loads parameters from local result node, current command preferences or default command preferences

		try {

			this.loadGenericParameters();

		return this.children.size() > 0;

	}

	/**

	 * Returns all the member fields of the class instance.

	 * @return

		}

		return fields;

	}

	/**

	 * Stores the parameters of the specified type used for last computing.

	 * @throws Exception

	 */

	protected void updateLastParameters(int parameterType) throws Exception {

		List<Field> fields = this.getAllFields();

		for (Field f : fields) {

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

			if (parameter == null || parameter.type() != parameterType) {

				continue;

			}

			String name;

			if(!parameter.key().isEmpty())	{

				name = parameter.key();

			else	{

				name = f.getName();

			}

			f.setAccessible(true);

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

		}

	}

	/**

	 * Stores the last parameters used for computing.

	 * @throws Exception

	protected void updateLastParameters() throws Exception {

		this.updateLastParameters(Parameter.COMPUTING);

	}

	// FIXME: not used?

	public HashMap<String, Object> getLastParameters() {

		return lastParameters;

	}

	/**

	 * Gets a current parameter specified by its annotation "key" attribute and its annotation "type" attribute.

	 * @param key

	protected Object getParameter(String key) {

		List<Field> fields = this.getAllFields();

		for (Field f : fields) {

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

			if (parameter == null) {

		return null;

	}

	/**

	 * Checks if a parameter value has changed since last computing.

	 * @param key

		}

	}

	public String dumpPreferences()	{

		StringBuilder str = new StringBuilder();

		str.append("Command preferences\n");

		str.append(TXMPreferences.getKeysAndValues(TXMPreferences.scope, this.preferencesNodeQualifier));

		str.append("\nDefault preferences\n");

		str.append(TXMPreferences.getKeysAndValues(DefaultScope.INSTANCE, this.preferencesNodeQualifier));

		return str.toString();

	}

	public String dumpParameters()	{

		return this.dumpParameters(Parameter.COMPUTING);

	}

	public String dumpParameters(int parametersType)	{

		StringBuilder str = new StringBuilder();

		str.append("Parameters (type = " + parametersType + " / " + Parameter.types[parametersType] + ")\n");

		List<Field> fields = new ArrayList<Field>();

		Class<?> clazz = this.getClass();

		while (clazz != Object.class) {

				continue;

			}

			f.setAccessible(true);

			String name;

			if(!parameter.key().isEmpty())	{

				name = parameter.key();

		}

		return str.toString();

	}

	/**

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

	 * 

		}

	}

	/**

	 * Updates the dirty states by comparing TXMResult @Parameter with previously used parameters in the compute() method.

	 * 

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

				continue;

			}

			String name;

			if(!"".equals(parameter.key()))	{

				name = parameter.key();

			else	{

				name = f.getName();

			}

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

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

			Object newValue = f.get(this);

			// FIXME: debug

			//System.err.println("TXMResult.isDirtyFromHistory(): checking parameter: " + name);

			this.updateDirty(previousValue, newValue);

			if (this.dirty) {

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

		return TXMPreferences.getDefaultScopeKeys(this.preferencesNodeQualifier);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or

	 * default preferences nodes.

		return true;

	}

	/**

	 * 

	 * @return

	protected boolean loadGenericParameters() throws Exception {

		return this.loadGenericParameters(Parameter.COMPUTING);

	}

	/**

	 * Initialize the @Parameter class members objects using the default and persisted values in the Preference Store

	 * 

	 * @throws Exception 

	 */

	protected boolean loadGenericParameters(int parameterType) throws Exception {

		List<Field> fields = this.getAllFields();

		for (Field f : fields) {

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

			if (parameter == null || parameter.type() != parameterType) {

				continue;

			}

			String key = parameter.key();

			if (key.isEmpty()) {

				continue; // no preference key defined for the parameter so it can't be filled with default value or result persistence value from preferences nodes

			}

			try {

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

				// only manage simple persisted types

				if(f.getType().isAssignableFrom(String.class)) {

					String persistedValue = this.getStringParameterValue(key);

				// FIXME: doesn't work

				//else if (f.getClass().equals(Boolean.class)) {

				else if (f.getType().isAssignableFrom(boolean.class)) {

					Boolean persistedValue = this.getBooleanParameterValue(key);

					if (persistedValue != null) {

						f.set(this, persistedValue);

	 * @throws Exception

	 */

	public abstract boolean loadParameters() throws Exception;

	/**

	 * Initialize the @Parameter class members objects

	 * 

	// */

	// public abstract String getComputingMessage();

	/**

	 * Convenience method to get a shared name when the result is empty (not yet computed).

	 * @return the String "*"

	public String getEmptyName()	{

		return "*"; 

	}

	/**

	 * Returns a string representation of a unique ID of the result.

	 * 

		return this.compute(false, null);

	}

	/**

	 * 

	 * @param update

	public boolean compute(boolean update, IProgressMonitor monitor) throws Exception {

		return this.compute(update, monitor, true);

	}

	/**

	 * Computes the result if 

	 * it can be computed 

		// 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._compute(update)) {

			// FIXME: Debug

	// FIXME: should be moved in an exporter extension

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

	public boolean getHasBeenComputedOnce() {

		return hasBeenComputedOnce;

	}

	/**

	 * increment the process

	 * 

import org.txm.index.rcp.editors.DictionnaryEditor;

import org.txm.index.rcp.editors.IndexEditor;

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

import org.txm.rcp.editors.TXMResultEditorInput;

import org.txm.rcp.handlers.BaseAbstractHandler;

import org.txm.rcp.StatusLine;

			return null;

		}

		return null;

	}

}

import org.txm.index.rcp.editors.DictionnaryEditor;

import org.txm.lexicon.core.corpusengine.cqp.Lexicon;

import org.txm.rcp.TXMWindows;

import org.txm.rcp.editors.TXMResultEditorInput;

import org.txm.rcp.handlers.BaseAbstractHandler;

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

		Object selection = this.getSelection(event);

		// New lexicon from corpus

		Index index = null;

		if (selection instanceof Corpus)	{

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		} else if(selection instanceof Index) { // Reopens an existing lexicon

			index = (Index) selection;

			System.out.println("DEBUG: re-openning "+index);

			return null;

		}

		return null;

	}

}

 * @author sjacquot

 *

 */

	/**

	 * The tool bar.

		super();

	}

	/**

	 * 

	 * @param chartEditorInput

	 */

		this(SWTChartsComponentsProvider.getCurrent(), chartEditorInput);

	}

	 * Convenience method the get the casted linked editor input.

	 * @return the editorInput

	 */

		return (ChartEditorInput) super.getEditorInput();

	}

	public Object getChart()	{

		return this.getResultData().getChart();

	}

	/**

	 * Returns the chart components provider associated with the editor (through its <code>ChartEditorInput</code>).

 * @author sjacquot

 *

 */

	@Deprecated

	 * @param result

	 * @param preferencesNodeQualifier

	 */

		this(SWTChartsComponentsProvider.getCurrent(), result);

	}

	 * @param result

	 * @param preferencesNodeQualifier

	 */

		this(swtComponentsProvider, result, null);

	}

	 * @param chartType

	 * @param chartContainer

	 */

		super(result);

		this.swtChartsComponentsProvider = swtComponentsProvider;

		this.chartContainer = chartContainer;

import org.txm.chartsengine.core.ChartCreator;

import org.txm.chartsengine.core.ChartsEngine;

import org.txm.chartsengine.core.preferences.ChartsEnginePreferences;

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

import org.txm.chartsengine.rcp.messages.SWTComponentsProviderMessages;

import org.txm.core.preferences.TXMPreferences;

 */

public class AdvancedChartEditorToolBar extends ToolBar {

		return chartEditorPart;

	}

	 * @param parent

	 * @param style

	 */

		super(parent, style); //$NON-NLS-1$

		final ToolItem showTitle = new ToolItem(this, SWT.CHECK);

		//showTitle.setText(SWTComponentsProviderMessages.SWTChartsComponentProvider_SHOW_HIDE_TITLE);

		showTitle.setDisabledImage(IImageKeys.getImage(getClass(), "icons/show_title_disabled.png"));

		showTitle.setToolTipText(SWTComponentsProviderMessages.SWTChartsComponentProvider_SHOW_HIDE_TITLE);

		}

		// disable if not managed by the command

		else	{

		showLegend.setDisabledImage(IImageKeys.getImage(getClass(), "icons/show_legend_disabled.png"));

		showLegend.setToolTipText(SWTComponentsProviderMessages.SWTChartsComponentProvider_SHOW_HIDE_LEGEND);

		}

		// disable if not managed by the command

		else	{

		showGrid.setDisabledImage(IImageKeys.getImage(getClass(), "icons/show_grid_disabled.png"));

		showGrid.setToolTipText(SWTComponentsProviderMessages.SWTChartsComponentProvider_SHOW_HIDE_GRID);

		}

		// disable if not managed by the command

		else	{

		renderingModeCombo.pack();

		renderingComboItem.setWidth(renderingModeCombo.getBounds().width);

		}

		// disable if not managed

		else	{

		// Font selection

		final Combo fontCombo = new Combo(this, SWT.READ_ONLY);

		String fonts[] = GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames();

				boolean update = true;

				if(e.getSource() == showTitle)	{

				}

				else if(e.getSource() == showLegend)	{

				}

				else if(e.getSource() == showGrid)	{

				}

				else if(e.getSource() == renderingModeCombo)	{

				}

				else if(e.getSource() == fontCombo || e.getSource() == fontSizeCombo)	{

				}

				else if(e.getSource() == chartTypeCombo)	{

					update = false;

				}

				// updates or creates chart

			}

			@Override

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.MenuItem;

import org.txm.chartsengine.rcp.IChartComponent;

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

import org.txm.chartsengine.rcp.events.EventCallBack;

	protected ArrayList<Menu> contextMenus;

	/**

	 *

	 * @param parent

	 * @param style

	 */

		super(parent, style);

		this.chartEditor = chartEditor;

import org.txm.cah.core.messages.AHCCoreMessages;

import org.txm.cah.core.preferences.AHCPreferences;

import org.txm.cah.rcp.messages.AHCUIMessages;

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

import org.txm.core.preferences.TXMPreferences;

import org.txm.rcp.IImageKeys;

 * @author sjacquot

 *

 */

	/**

	 * Numbers of clusters.

		this.numbersOfClusters.setSelection(TXMPreferences.getInt(AHCPreferences.PREFERENCES_NODE, this.getResultData(), AHCPreferences.N_CLUSTERS));

	}

}

					fMin = d.getFmin();

					vMax = d.getMaxLines();

					LexicalTable lexicaltable = new LexicalTable(partition, property, fMin, vMax); // use the CAPreferencePage Fmin

					ahc = new AHC(new CA(lexicaltable));

				} else {

					// canceled

					return null;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.layout.RowLayout;

import org.eclipse.swt.widgets.Composite;

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

import org.eclipse.ui.IWorkbenchPartSite;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.menus.IMenuService;

import org.eclipse.ui.part.EditorPart;

import org.txm.core.results.TXMResult;

import org.txm.rcp.JobsTimer;

import org.txm.rcp.StatusLine;

import org.txm.rcp.TXMWindows;

import org.txm.rcp.utils.JobHandler;

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

import org.txm.utils.logger.Log;

 * @author sjacquot

 *

 */

	/**

	 * The editor main tool bar, positioned at the top of the editor.

	}

	@Override

        return (TXMResultEditorInput) super.getEditorInput();

    }

	 * Returns the result object associated with the editor through its editor input.

	 * @return

	 */

		return this.getEditorInput().getResult();

	}

	public final void compute(boolean update) {

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

	}

	/**

	 * Internal method to mutualize compute editor creation

	 * 

 * @author sjacquot

 *

 */

	/**

	 * 

	/**

	 * TXM result object.

	 */

	/**

	 * Creates an editor input and stores the specified TXM result as source object for further result computing.

	 * @param sourceResult

	 * @param preferencesNodeQualifier

	 */

		this.result = result;

		this.alwaysRecreateEditor = false;

	}

	 * Gets the TXM result associated with the editor input.

	 * @return the linked result

	 */

		return result;

	}

	 * Sets the result data associated with the editor input.

	 * @param resultData the resultData to set

	 */

		this.result = resultData;

	}