Laboratoire ICAR » Plateforme TXM

		this.chartDirty = true;

	}

	@Override

	public boolean compute(IProgressMonitor monitor) {

		try {

			Log.finest("*** ChartResult.compute(): " + this.getClass().getSimpleName() + ": starting computing process...");

			// compute the result if needed

				// compute the chart

				return renderChart();

			}

			_compute_with_lists();

		}

		return true;

	}

	@Override

	public String getDetails() {

	}

	/**

	public int getPartsCount() {

		// FIXME: later should just return the direct children count

		try {

			return getParts().size();

		} catch(Exception e) { }

		return 0;

	 * @throws CqiClientException

	 */

	public int getTotalSize() throws CqiClientException {

		if (totalsize == -1) {

			totalsize = 0;

			for (Part p : getParts()) {

import org.eclipse.ui.handlers.HandlerUtil;

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

import org.txm.rcp.handlers.BaseAbstractHandler;

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

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

import org.txm.specificities.rcp.editors.SpecificitiesEditor;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		Object selection = this.getCorporaViewSelectedObject(event);

		SpecificitiesSelection specificitiesSelection = null;

		// Reopening from existing result

			specificitiesSelection = (SpecificitiesSelection) selection;

		}

		// Creates from SpecificitiesEditor selected table lines

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.TreeItem;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

	public static HashMap<String, String> doubleClickInstalledCommands = new HashMap<String, String>();

	/**

			treeViewer.setContentProvider(new TXMResultContentProvider(this));

			//treeViewer.setLabelProvider(new TextometrieLabelProvider());

			//treeViewer.setLabelProvider(new DecoratingLabelProvider(new TXMResultLabelProvider(),PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator()));

			treeViewer.setLabelProvider(new DecoratingLabelProvider(new WorkbenchLabelProvider(), PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator()));

			Workspace w = Toolbox.workspace;

			if (w == null) return;

			treeViewer.setInput(w);

		treeViewer.setColumnProperties(new String[]{"name"}); // mandatory to enable edit mode -> used to identify columns

		//		treeViewer.addFilter(new ViewerFilter() {

		//			@Override

		treeViewer.setContentProvider(new TXMResultContentProvider(this));

		//treeViewer.setLabelProvider(new TextometrieLabelProvider());

		//treeViewer.setLabelProvider(new DecoratingLabelProvider(new TXMResultLabelProvider(), PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator()));

		treeViewer.setLabelProvider(new DecoratingLabelProvider(new WorkbenchLabelProvider(), PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator()));

		// for now the sorter is used to sort the Corpus, Subcorpus and partition objects

		treeViewer.setSorter(new ViewerSorter() {

			public int category(Object element) {

				if (arg0.keyCode == SWT.DEL) {

					final ISelection sel = treeViewer.getSelection();

					if (sel instanceof IStructuredSelection) {

						if (!DeleteObject.askContinueToDelete((IStructuredSelection)sel)) return;

						JobHandler job = new JobHandler("Deleting", true) {

							@Override

		});

		// FIXME: show icon for results that are user persistable

		MenuManager menuManager = new MenuManager();

		Menu menu = menuManager.createContextMenu(treeViewer.getTree());

			corporaView.treeViewer.reveal(obj);

		}

	}

}

import org.txm.core.messages.TXMCoreMessages;

import org.txm.core.results.Parameter;

import org.txm.core.results.TXMResult;

import org.txm.rcp.JobsTimer;

import org.txm.rcp.StatusLine;

import org.txm.rcp.TXMWindows;

 * @author sjacquot

 *

 */

	/**

	 * ID to use in plugin.xml to contribute to the top toolbar.

	 */

	protected boolean dirty;

	@Override

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

		this.setSite(site);

		this.setInput(input);

		this.result = getEditorInput().getResult(); // store result for debug purpose

		// FIXME: see how to use the Adapters and AdapterFactory to define image and title of Editor in the contributing plug-ins

		// another way is to use editors extension in plug-ins and redefine icon and name, using this solution the problem is that the name (which is also editor title) can not be dynamic according to the result data

		// so it seems better to use Adapters if it's possible or keep this solution below

		IPartListener2 pl = new IPartListener2() {

			// ... Other methods

			public void partClosed(IWorkbenchPartReference partRef) {

				if (partRef.getId().equals(TXMEditor.this.getClass().getName())) { // called after this.doSave() 

					//System.out.println("EVENT partClosed");

					for (TXMEditorExtension<T> b : extensions) {

	public GLComposite getFirstLineComposite() {

		return firstLineComposite;

	}

	public Shell getShell() {

		if (parent !=null && !parent.isDisposed()) {

	}

	@Override

		// FIXME: SJ: to discuss. A this moment the save is automatically done or not in TXMResult.compute() according to a preference of the TBX

		//		if (TBXPreferences.getInstance().getBoolean(TBXPreferences.AUTO_SAVE_RESULTS)) { // ?

		//			getResult().saveParameters();

		//		}

		/// FIXME: SJ: dirty state tests

		notifyExtensions("notifyDoSave"); //$NON-NLS-1$

		firePropertyChange(IEditorPart.PROP_DIRTY);

//								setDirty(false);

								refresh(update);

							} catch (Exception e) {

								Log.finest("TXMEditor.compute(): " + TXMEditor.this.getClass().getSimpleName() + ": Error while refreshing the editor: " + e); //$NON-NLS-1$

								Log.printStackTrace(e);

		return editor;

	}

	/**

	 * Synchronizes the editor with the result and refreshes the corpus view.

	 * Also fires a dirty property change.

		// FIXME: debug test to not draw while updating the widgets

		this.getContainer().setRedraw(true);

		/// FIXME: SJ: dirty state tests

		this.setDirty(false);

		notifyExtensions("notifyEndOfRefresh"); //$NON-NLS-1$

	}

	public abstract void updateResultFromEditor();

	/**

	 * Synchronizes the editor with the result. 

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

	 * <p>

	 * Use this method if you need to save parameter with Type not managed by the autoUpdateEditorFieldsFromResult method

	 * @throws Exception 

	 */

	public abstract void updateEditorFromResult(boolean update) throws Exception;

            restorable="true">

      </view>

      <view

            category="org.txm.rcp.debug"

            class="org.txm.rcp.views.SummaryView"

            id="org.txm.rcp.views.InternalCorpusView"

				for(String key : preferences.keys()) {

					dstPreferences.put(key, preferences.get(key, ""));

				}

			}

			catch(BackingStoreException e) {

				// TODO Auto-generated catch block

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.concurrent.Semaphore;

import java.util.regex.Pattern;

 * 

 * A TXMResult always have a parent (except the root: @see Workspace).

 * 

 * 

 * 

 * 

 * Groovy call sample :

 * <pre>

 * {@code

 * MyTXMResult result = new MyTXMResult(parent);

 * </pre>

 * 

 * @author mdecorde

 * @author sjacquot

 */

public abstract class TXMResult implements Cloneable, IProgressMonitor, Comparable<TXMResult> {

	public static final String UNDERSCORE = "_";

	private static int next = 0;

	/**

	 * Editor can use this to test if the result has been computed once.

	protected int weight;

	/**

	 */

	protected boolean dirty = true;

	/**

	 * if frozen, the result is not updated when computed

	 */

	protected boolean frozen = false;

	/**

	 */

	protected boolean altered = false;

	 * Command preferences node path.

	 */

	protected String commandPreferencesNodePath;

	/**

	 */

	protected String parametersNodePath;

	private Semaphore progressSemaphore = new Semaphore(1);

	/**

	 */

	// But this stack is also the start for an UNDO command on TXMResult.

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

	/**

	 * Internal persistable state.

	 */

	/**

	 * The visibility state.

	 */

	private Boolean visible;

	/**

	 * The user name (to rename a result).

	 */

	protected String userName;

	/**

	 */

	private String lazyName;

	/**

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

	 * @param parent

	 */

	public TXMResult(TXMResult parent) {

	}

	/**

	 * @param uuid

	 */

	public TXMResult(String parametersNodePath) {

	}

	/**

	 * 

	 * @param uuid

	 * @param parent

			parent.addChild(this);

		}

				parametersNodePath = this.getProject().getParametersNodeRootPath();

			} else {

				parametersNodePath = "";

			}

			this.parametersNodePath = parametersNodePath;

		}

		this.weight = 0;

		this.children = new ArrayList<TXMResult>(1);

		Log.finest("TXMResult.TXMResult(): command preferences node path: " + this.commandPreferencesNodePath + "."); //$NON-NLS-1$ //$NON-NLS-2$

		this.visible = true;

		this.dirty = true;

		this.internalPersistable = false;

		this.userPersistable = TBXPreferences.getInstance().getBoolean(TBXPreferences.AUTO_PERSISTENCE_ENABLED);

		// retrieving parent from UUID

		String parentNodePath = this.getStringParameterValue(TXMPreferences.PARENT_PARAMETERS_NODE_PATH);

		if (!("ROOT".equals(this.parametersNodePath)) && // search for parent only if UUID != "ROOT"

			Log.finest("Searching parent with UUID: " + parentNodePath + "..."); //$NON-NLS-1$ //$NON-NLS-2$

			TXMResult retrievedParent = TXMResult.getResult(parentNodePath);

			if (retrievedParent != null) {

				Log.finest("Parent retrieved from UUID: " + retrievedParent + "."); //$NON-NLS-1$ //$NON-NLS-2$

				retrievedParent.addChild(this);

				Log.severe("Warning: no parent was found in project for path=" + parametersNodePath + " and puuid=" + parentNodePath + " preferences=" + this.dumpParameters()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

				// FIXME: commented for now

				return;

			}

		}

		try {

			this.autoLoadParametersFromAnnotations(); // auto fill from Parameter annotations

		} catch (Exception e) {

			Log.severe("Fail to load " + parametersNodePath + "result: " + e); //$NON-NLS-1$ //$NON-NLS-2$

			Log.printStackTrace(e);

		}

		// Log

			Log.finest("Warning: the TXMResult of " + this.getClass() + " is attached to no parent. (uuid = " + this.parametersNodePath + ")");//$NON-NLS-1$ //$NON-NLS-2$

		}

		try {

			this.parametersHistory.add(new HashMap<String, Object>());

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	/**

	 * Sets the user name.

	 * @param name

	 */

	public void setUserName(String name) {

	public boolean isAltered() {

		return altered;

	}

	/**

	 * Mark the result as altered -> modifications are lost after a re-compute

	 */

	public void setAltered() {

		this.altered = true;

	}

	/**

	 * Freezes the result -> cannot be recomputed.

	 */

	public void freeze() {

		this.frozen = true;

	}

	/**

	 * Unfreezes the result -> can be recomputed.

	 */

	public void setFrozen(boolean frozen) {

		this.frozen = frozen;

	}

	/**

	 * @return true if the resutl is frozen

	 */

	public boolean isFrozen() {

		return this.frozen;

	}

	/**

	 * Creates an UUID dedicated to persistence of this result.

	 * @return

	 */

	public static String createUUID() {

		return UUID_PREFIX + ID_TIME_FORMAT.format(new Date(System.currentTimeMillis())) + "_" + nextInt();

	}

	/**

	 * 

	 * @return the next integer in the current session of TXM

	/**

	 * Checks if the result at least one child.

	 * @return

	 */

	public boolean hasChildren() {

		return this.children.size() > 0;

	}

	/**

	 * Gets the preferences node path of the result command.

	 * 

		return this.commandPreferencesNodePath;

	}

	public String[] getCommandPreferencesKeys() throws BackingStoreException {

		return TXMPreferences.getCommandScopeKeys(this.commandPreferencesNodePath);

	}

	}

	/**

	 * @param key

	 * @param parameterType

	 * @return

	}

	/**

	 * @param key

	 * @param parameterType

	 * @return

	 */

	public Object getParameter(String key, boolean propagateToParent) {

		try {

				field.setAccessible(true);

			} else if (propagateToParent && this.parent != null) {

				return this.parent.getParameter(key, propagateToParent);

			}

		return null;

	}

	/**

	 * Gets a member field according to its key.

	 * @param key

	 * @return the field if exists otherwise null

	 */

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

	/**

	 * Returns all the member fields of the class instance.

	 * @return the list of declared fields

	 */

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

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

	/**

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

	 * @throws Exception

	 */

	protected void updateLastParameters(int parameterType) throws Exception {

		this.updateLastParameters(parameterType, false);

	}

	/**

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

	 * @param parameterType

	 * @param appendToLastParameters

	 * @throws Exception

		HashMap<String, Object> lastParameters;

			lastParameters = this.getLastParametersFromHistory();

			lastParameters = new HashMap<>();

		}

			}

			String name;

				name = parameter.key();

				name = f.getName();

			}

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

		}

			this.parametersHistory.add(lastParameters);

		}

		// truncate the stack to the max count

		// FIXME: store this in a TBX preference

			this.parametersHistory.remove(0);

			this.parametersHistory.remove(0);

			this.parametersHistory.remove(0);

	/**

	 * Stores the last parameters used for computing.

	 * @throws Exception

	 */

	protected void updateLastParameters() throws Exception {

		this.updateLastParameters(Parameter.COMPUTING);

	}

	/**

	 * 

	 * @param parameterType

			}

			String name;

				name = parameter.key();

				name = f.getName();

			}

			this.getLastParametersFromHistory().remove(name);

		}

			this.parametersHistory.remove(this.parametersHistory.size() - 1);

		}

	}

	/**

	 * @throws Exception

	 */

	protected void clearLastComputingParameters() {

		this.clearLastParameters(Parameter.COMPUTING);

	}

	/**

	 * @param key

	 * @param older

	 * @return

	 */

	public boolean hasParameterChanged(String key, boolean older) {

			return this.hasParameterChanged(key);

		}

	}

	/**

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

	 * @param key

	 * @param parameterType

	 * @return

	}

	/**

	 * @param key

	 * @param lastParameters

	 * @return

		if (key.isEmpty()) {

			return false;

		}

		Object lastValue = lastParameters.get(key);

		Object newValue = this.getParameter(key);

		if (lastValue == null) {

				return true;

				return false;

			}

			return !lastValue.equals(newValue);

		}

	}

	/**

	 * @return

	 */

		StringBuilder str = new StringBuilder();

			str.append("\nResult local node preferences\n"); //$NON-NLS-1$

			str.append(TXMPreferences.getKeysAndValues(this.getParametersNodePath()));

		}

		return str.toString();

	}

	/**

	 * Dumps the result computing parameters (Parameter annotation).

	 * @return

	 */

		return this.dumpParameters(Parameter.COMPUTING);

	}

	/**

	 * Dumps the result computing parameters (Parameter annotation).

	 * @param parametersType

	 * @return

	 */

		StringBuilder str = new StringBuilder();

			f.setAccessible(true);

			String name;

				name = parameter.key();

				name = f.getName();

			}

			try {

				Object v = f.get(this);

				if (v != null) {

				} else {

					str.append(name + " = NULL \n"); //$NON-NLS-1$ //$NON-NLS-2$

				}

				// TODO Auto-generated catch block

				e.printStackTrace();

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		return str.toString();

	}

	/**

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

	 * 

	 */

	protected void updateDirty(Object lastValue, Object newValue) {

			return;

		}

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

			this.setDirty();

		}

	}

	/**

	 * 

	 * 

	 * 

	 * Implement isDirty if you need more test

	 * 

	 * @return

	 */

	public final boolean isDirtyFromHistory() throws Exception {

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

		for (Field f : fields) {

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

				continue;

			}

			String name;

				name = parameter.key();

				name = f.getName();

			}

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

			Object newValue = f.get(this);

			this.updateDirty(previousValue, newValue);

			if (this.dirty) {

		return this.dirty;

	}

		return this.parametersHistory.get(this.parametersHistory.size() - 1);

	}

	}

	/**

	 */

	public void setDirty() {

		this.setDirty(true);

	}

	/**

	 * @param dirty

	 */

	public void setDirty(boolean dirty) {

			this.children.get(i).setDirty(dirty);

		}

	}

	/**

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

		return TXMPreferences.getString(key, this, this.commandPreferencesNodePath);

	}

	/**

	 * Checks if the specified parameter exists.

	 * @param key

	 * @return

	 */

		return TXMPreferences.keyExists(this.parametersNodePath, key);

	}

	/**

	 * @param key

	 * @return

	 */

		return TXMPreferences.isEmpty(this.commandPreferencesNodePath, key);

	}

	/**

	 * 

	 * @param key

	 * @return

		this.saveParameter(key, StringUtils.join(values, UNDERSCORE));

	}

	/**

	 * @param result

	 * @param key

	 * @param value

	 */

		// FIXME: debug

		TXMPreferences.putLocal(this, key, value);

	}

	/**