/ - Diff - Plateforme TXM - Forge du Centre Blaise Pascal

Révision 2558

     		// set result as persistent if AUTO_PERSISTENCE_ENABLED preference is activated
     		if (TBXPreferences.getInstance().getBoolean(TBXPreferences.AUTO_PERSISTENCE_ENABLED)) {
     			this.userPersistable = true;
     			this.saveParameter(TXMPreferences.PERSITABLE, true);
+    		}
     		// retrieving parent from UUID
-...
     			Log.finest("Searching parent with UUID " + parentNodePath + "..."); //$NON-NLS-1$ //$NON-NLS-2$
     			// TODO this is quite CPU expensive because 'retrievedParent' is researched in all projects
     			// FIXME: MD: this is quite CPU expensive because 'retrievedParent' researches in all projects
     			TXMResult retrievedParent = TXMResult.getResult(parentNodePath);
     			if (retrievedParent != null) {
     				Log.finest("Parent retrieved from UUID: " + retrievedParent + "."); //$NON-NLS-1$ //$NON-NLS-2$
-...
     	/**
     	 * Gets the children results specified by their class.
+    	 *
     	 * @param type
     	 * @param clazz
     	 * @return
     	 */
     	public List<? extends TXMResult> getChildren(Class type) {
     		return TXMResult.getNodes(this.children, type, false);
     	public List<? extends TXMResult> getChildren(Class<? extends TXMResult> clazz) {
     		return TXMResult.getNodes(this.children, clazz, false);
+    	}
     	/**
     	 * Gets the children results specified by their class.
+    	 *
     	 * @param type
     	 * @param clazz
     	 * @return
     	 */
     	public List<TXMResult> getChildren(Class type, boolean onlyVisible) {
     		return TXMResult.getNodes(this.children, type, onlyVisible);
     	public List<TXMResult> getChildren(Class<? extends TXMResult> clazz, boolean onlyVisible) {
     		return TXMResult.getNodes(this.children, clazz, onlyVisible);
+    	}
     	/**
     	 * Gets the first child result specified by its class.
+    	 *
     	 * @param type
     	 * @param clazz
     	 * @return the first child if exists otherwise null
     	 */
     	public TXMResult getFirstChild(Class type) {
     		List<TXMResult> children = this.getChildren(type, false);
     	public TXMResult getFirstChild(Class<? extends TXMResult> clazz) {
     		List<TXMResult> children = this.getChildren(clazz, false);
     		try {
     			return children.get(0);
+    		}
-...
     	/**
     	 * Deletes the children of the specified class.
+    	 *
     	 * @param type
     	 * @param clazz
     	 * @return
     	 */
     	public void deleteChildren(Class type) {
     		List<TXMResult> children = (List<TXMResult>) this.getChildren(type);
     	public void deleteChildren(Class<? extends TXMResult> clazz) {
     		List<TXMResult> children = (List<TXMResult>) this.getChildren(clazz);
     		for (int i = 0; i < children.size(); i++) {
     			children.get(i).delete();
+    		}
+    	}
     	/**
     	 * Gets the first child.
+    	 *
     	 * @param classSimpleName
     	 * @return
     	 */
     	public TXMResult getFirstChild() {
     		try {
     			return this.children.get(0);
+    		}
     		catch (Exception e) {
+    		}
     		return null;
+    	}
     	/**
     	 * Gets the children of all the branch of the specified node in a flat list.
     	 * Gets the children of all the branch of the specified node in a flat list according to their specified class.
+    	 *
     	 * @param parent
     	 * @param clazz
     	 * @return
     	 */
     	protected static List<TXMResult> getDeepChildren(TXMResult parent, Class<? extends TXMResult> clazz) {
     		List<TXMResult> results = new ArrayList<>();
     		List<? extends TXMResult> cc = parent.getChildren(clazz);
     		for (TXMResult r : cc) {
     			results.add(r);
     			results.addAll(r.getDeepChildren());
     		List<? extends TXMResult> children = parent.getChildren(clazz);
     		for (int i = 0; i < children.size(); i++) {
     			TXMResult child = children.get(i);
     			results.add(child);
     			results.addAll(child.getDeepChildren(clazz));
+    		}
     		return results;
+    	}
-...
+    	 *
     	 * @return
     	 */
     	public static List<TXMResult> getDeepChildren(TXMResult r) {
     		return TXMResult.getDeepChildren(r, null);
     	public static List<TXMResult> getDeepChildren(TXMResult result) {
     		return TXMResult.getDeepChildren(result, null);
+    	}
     	/**
-...
+    	}
     	/**
     	 * Gets the TXMResult specified by its UUID in the children of the specified root result.
     	 * Gets the TXMResult specified by its node path (UUID) in the children of the specified root result.
     	 * Returns the root itself if the specified node path is equal to the root node path.
+    	 *
     	 * @param branchRoot
     	 * @param UUID
     	 * @param root
     	 * @param nodePath
     	 * @return
     	 */
     	public static TXMResult getResult(TXMResult root, String nodePath) {
     		TXMResult result = null;
     		// returns the root itself if the specified node path is equal to the root node path
     		if (root.getParametersNodePath().equals(nodePath)) {
     			return root; // root is the node we are looking for
     			return root;
+    		}
     		else {
     			List<TXMResult> results = root.getChildren();
     			for (int i = 0; i < results.size(); i++) {
     				if (results.get(i).getParametersNodePath().equals(nodePath)) {
     					return results.get(i); // a direct children is the node we are looking for
     			List<TXMResult> children = root.getChildren();
     			// pass 1: to optimize, search in direct children
     			for (int i = 0; i < children.size(); i++) {
     				if (children.get(i).getParametersNodePath().equals(nodePath)) {
     					return children.get(i);
+    				}
+    			}
     			for (int i = 0; i < results.size(); i++) {
     				TXMResult r = getResult(results.get(i), nodePath);
     				if (r != null) {
     					return r; // a deep children is the node we are looking for
     			// pass 2: deep recursively search in all children
     			for (int i = 0; i < children.size(); i++) {
     				TXMResult result = getResult(children.get(i), nodePath);
     				if (result != null) {
     					return result;
+    				}
+    			}
+    		}
     		return null; // not found
+    	}
     	/**
     	 * Gets the TXMResult specified by its UUID in the children of the Toolbox Workspace member.
     	 * Gets the TXMResult specified by its node path (UUID) in the children of the Toolbox Workspace (root of the tree).
+    	 *
     	 * @param UUID
     	 * @param nodePath
     	 * @return
     	 */
     	public static TXMResult getResult(String nodePath) {
-...
+    	}
     	/**
     	 * Filters the nodes specified by their class and their visibility state.
     	 * Filters the nodes of the specified source nodes list according to by their class and their visibility state.
+    	 *
     	 * @param type
     	 * @return
     	 * @param srcNodes
     	 * @param clazz
     	 * @param onlyVisible
     	 * @return a new filtered nodes list
     	 */
     	protected static List<TXMResult> getNodes(List<TXMResult> srcNodes, Class<? extends TXMResult> type, boolean onlyVisible) {
     	protected static List<TXMResult> getNodes(List<TXMResult> srcNodes, Class<? extends TXMResult> clazz, boolean onlyVisible) {
     		List<TXMResult> nodes = new ArrayList<>();
     		for (TXMResult child : srcNodes) {
     			try {
     				if ((type == null ||
     						child.getClass().asSubclass(type) != null)
     				if ((clazz == null ||
     						child.getClass().asSubclass(clazz) != null)
     						&& (onlyVisible == false || child.isVisible())) {
     					nodes.add(child);
+    				}
     				// add children of a non visible result
     				else if (!child.isVisible() && child.hasChildren()) {
     					List<TXMResult> subChidlren = child.getChildren(type, onlyVisible);
     					List<TXMResult> subChidlren = child.getChildren(clazz, onlyVisible);
     					nodes.addAll(subChidlren);
+    				}
+    			}
-...
     	/**
     	 * Gets the root parent of the branch.
     	 * Returns the result itself if it's the root.
+    	 *
     	 * @return
     	 */
-...
     	/**
     	 * Gets the first parent of the specified class, eg. this.getFirstParent(Partition.class);
     	 * Gets the first parent of the specified class, e.g. this.getFirstParent(Partition.class);
+    	 *
     	 * @param type
     	 * @return
     	 * @param clazz the class of parent to look for
     	 * @return the first parent of the specified class if exist otherwise null
     	 */
     	public TXMResult getFirstParent(Class type) {
     	public TXMResult getFirstParent(Class<? extends TXMResult> clazz) {
     		TXMResult node = null;
     		TXMResult parent = this.parent;
     		do {
     			if (parent != null) {
     				if (parent.getClass().equals(type)) {
     				if (parent.getClass().equals(clazz)) {
     					node = parent;
+    				}
-...
     	/**
     	 * Checks if the specified result is a child.
     	 * Checks if the specified result is a child of this result.
+    	 *
     	 * @return
     	 * @return true if the specified result is a child of this result otherwise false
     	 */
     	public boolean isChild(TXMResult child) {
     		return this.getDeepChildren().contains(child);
-...
     	/**
     	 * Gets the sibling nodes of this node result.
     	 * Returns an empty list if the node has no siblings.
+    	 *
     	 * @return a list of the sibling nodes of this result
     	 */
     	public List<TXMResult> getSiblings() {
     		List<TXMResult> sibling = new ArrayList<>();
-...
     	/**
     	 * Gets the sibling nodes of this node result, specified by their class.
     	 * Returns an empty list if the node has no siblings of the specified class.
+    	 *
     	 * @param clazz the class of siblings to look for
     	 * @return
     	 */
     	public List<TXMResult> getSiblings(Class type) {
     	public List<TXMResult> getSiblings(Class<? extends TXMResult> clazz) {
     		List<TXMResult> sibling = new ArrayList<>();
     		if (this.parent != null) {
     			sibling.addAll(TXMResult.getNodes(this.parent.getChildren(), type, true));
     			sibling.addAll(TXMResult.getNodes(this.parent.getChildren(), clazz, true));
     			sibling.remove(this);
+    		}
     		return sibling;
-...
     	/**
     	 * Checks if the result must be displayed.
+    	 *
     	 * @return
     	 * @return true if the result must be displayed otherwise false
     	 */
     	public boolean isVisible() {
     		return this.visible;
+    	}
     	/**
     	 * Checks if the parent of this result must be displayed.
+    	 *
     	 * @return true if the parent of this result must be displayed otherwise false
     	 */
     	public boolean isParentVisible() {
     		return parent != null && (parent.isVisible() || parent.isInternalPersistable());
+    	}
-...
     	 * Dedicated to UI purposes.
+    	 *
     	 * @param visible
     	 * @return
     	 */
     	public void setVisible(boolean visible) {
     		this.visible = visible;
+    	}
     	/**
     	 * Sets the parent.
     	 * Sets the parent of this result.
+    	 *
     	 * @param parent
     	 * @param parent the parent to set
     	 */
     	public void setParent(TXMResult parent) {
     		this.parent = parent;
+    	}
     	/**
     	 * Gets the parent.
     	 * Gets the parent of this result.
+    	 *
     	 * @return the parent
     	 */
-...
+    	 *
     	 * @param userPersistable the state to set
     	 */
     	protected void setUserPersistable(boolean userPersistable, boolean deep) {
     	public void setUserPersistable(boolean userPersistable) {
     		if (this.userPersistable == userPersistable) {
     			return;
+    		}
     		this.userPersistable = userPersistable;
     		// 1- MANAGE THE PARENTS
     		// recursively force the persistable state of the parents if this result is set to persistable
     		if (userPersistable && this.parent != null && !this.parent.isInternalPersistable()) {
     			this.parent.setUserPersistable(true, false);
     			this.parent.setUserPersistable(true);
+    		}
     		// recursively unpersist hidden parents
     		else if (!userPersistable && !this.parent.isVisible()) {
     			this.parent.setUserPersistable(false, false);
     			this.parent.setUserPersistable(false);
+    		}
     		// 2- MANAGE THE CHILDREN
     		// recursively force non-persistable state of children if this result is set to non-persistable
     		// also transfer this result state to its children marked as "must be synchronized with parent"
     		if (deep) {
     			for (TXMResult child : this.getChildren()) {
     				if (!userPersistable || child.mustBeSynchronizedWithParent()) {
     					child.setUserPersistable(userPersistable);
+    				}
     		for (TXMResult child : this.getChildren()) {
     			if (!userPersistable || child.mustBeSynchronizedWithParent()) {
     				child.setUserPersistable(userPersistable);
+    			}
+    		}
-...
+    		}
+    	}
     	/**
     	 * Sets the user defined persistable state of the result and its children.
+    	 *
     	 * @param userPersistable
     	 */
     	public void setUserPersistable(boolean userPersistable) {
     		this.setUserPersistable(userPersistable, true);
+    	}
     	/**
     	 * Swaps the user persistable state.

     /**
      * Base class of all charts SWT <code>EditorPart</code> subclasses.
+     *
      * @author sjacquot
+     *
      */
     public abstract class ChartEditor<T extends ChartResult> extends TXMEditor<ChartResult>{
     public abstract class ChartEditor<T extends ChartResult> extends TXMEditor<ChartResult> {
     	public final static String CONTEXT_ID_CHART_EDITOR = ChartEditor.class.getName();
     	// ChartEditor RCP context activation/deactivation
     	static	{
     	static {
     		IPartService service = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getPartService();
     		service.addPartListener(new IPartListener() {
-...
     			@Override
     			public void partDeactivated(IWorkbenchPart part) {
     				if(part instanceof ChartEditor)	{
     				if (part instanceof ChartEditor) {
     					((ChartEditor) part).onPartDeactivated();
+    				}
+    			}
-...
     			@Override
     			public void partActivated(IWorkbenchPart part) {
     				if(part instanceof ChartEditor)	{
     				if (part instanceof ChartEditor) {
     					((ChartEditor) part).onPartActivated();
+    				}
+    			}
-...
     	/**
     	 * SWT chart components provider used to create the chart composite.
     	 * Store it allows the switch of component provider in the RCP in keeping the chart editors in a coherent state, by testing that the SWT Components providers charts engine match the result charts engine.
     	 * Store it allows the switch of component provider in the RCP in keeping the chart editors in a coherent state, by testing that the SWT Components providers charts engine match the result charts
     	 * engine.
     	 */
     	protected SWTChartsComponentsProvider swtChartsComponentsProvider;
     	/**
     	 * The tool bar.
     	 */
     	protected ChartEditorToolBar chartToolBar;
     	/**
     	 * Export chart editor view tool item button.
     	 */
     	protected ToolItem exportChartEditorViewButton;
     	/**
     	 * Copy chart view to clipboard tool item button.
     	 */
-...
     	 * The advanced rendering parameters group.
     	 */
     	protected Group advancedToolBarGroup;
     	/**
     	 * The chart drawing area composite.
     	 */
     	protected ChartComposite chartComposite;
     	/**
     	 * To check whether this editor was already opened when calling SWTChartsComponentsProvider.openEditor().
     	 */
-...
     	 * The multi pages editor which contains this editor if exists.
     	 */
     	protected TXMMultiPageEditor parentMultiPagesEditor = null;
     	/**
     	 * Token used to deactivate the context after it has been activated.
     	 * The context is used by the RCP to bind keys or contextual menu to an editor.
     	 * The context is used by the RCP to bind keys or contextual menu to an editor.
     	 */
     	protected IContextActivation contextActivationToken;
     	/**
+    	 *
     	 */
     	public ChartEditor()	{
     	public ChartEditor() {
     		super();
+    	}
     	/**
     	 * Creates a new editor.
+    	 *
     	 * @param swtComponentsProvider
     	 * @param chartEditorInput
     	 */
-...
     		this.wasAlreadyOpened = false;
+    	}
     	/**
     	 * Subclasses manual creation.
     	 * @throws Exception
+    	 *
     	 * @throws Exception
     	 */
     	public abstract void __createPartControl() throws Exception;
-...
     		// Toolbar
     		this.chartToolBar = new ChartEditorToolBar(this, this.getFirstLineComposite(), null, SWT.FLAT | SWT.RIGHT);
     		this.getFirstLineComposite().getLayout().numColumns += 1;
     		this.exportChartEditorViewButton = this.chartToolBar.getItemByContributionId("exportChartEditorView"); //$NON-NLS-1$
     		this.copyChartViewToClipboardButton = this.chartToolBar.getItemByContributionId("copyChartViewToClipboard"); //$NON-NLS-1$
     		// Advanced tool bar
     		Group group = this.topToolBar.installGroup(ChartsUIMessages.rendering, ChartsUIMessages.showHideRenderingParameters,
     		Group group = this.topToolBar.installGroup(ChartsUIMessages.rendering, ChartsUIMessages.showHideRenderingParameters,
     				"platform:/plugin/org.txm.chartsengine.rcp/icons/show_rendering_parameters.png",  //$NON-NLS-1$
     				"platform:/plugin/org.txm.chartsengine.rcp/icons/hide_rendering_parameters.png", //$NON-NLS-1$
     				false);
     		this.advancedChartToolBar = new AdvancedChartEditorToolBar(this, group, this.getParametersGroupsComposite(), SWT.FLAT);
     		this.swtChartsComponentsProvider = SWTChartsComponentsProvider.getComponentsProvider(this.getResult().getChartsEngine());
     		if(this.swtChartsComponentsProvider == null)	{
     		if (this.swtChartsComponentsProvider == null) {
     			throw new Exception("No suitable component found to render the specified chart.");
+    		}
-...
     		GridData gd = new GridData(GridData.FILL_BOTH);
     		this.chartComposite.setLayoutData(gd);
     		 // subclasses manual creation
     		// subclasses manual creation
     		this.__createPartControl();
     		// repack the toolbars after eventual item adding by subclasses
     		// repack the toolbars after eventual item adding by subclasses
     		this.chartToolBar.pack();
     		this.advancedChartToolBar.pack();
+    	}
     	@Override
     	public void setDirty(boolean dirty) {
     		super.setDirty(dirty);
-...
     	/**
     	 * Opens an editor where id is the specified result class name, computes the result then refreshes the editor components.
+    	 *
     	 * @param result
     	 */
     	public static ChartEditor openEditor(ChartResult result) {
     		return openEditor(result, false);
+    	}
     	/**
+    	 *
     	 * @param result
     	 * @param alwaysRecreateEditor
     	 * @return
     	 */
     	public static ChartEditor openEditor(ChartResult result, boolean alwaysRecreateEditor)	{
     	public static ChartEditor openEditor(ChartResult result, boolean alwaysRecreateEditor) {
     		return openEditor(result, result.getClass().getName(), alwaysRecreateEditor);
+    	}
-...
     	 * @param editorPartId
     	 * @return
     	 */
     	public static ChartEditor openEditor(ChartResult result, String editorPartId)	{
     	public static ChartEditor openEditor(ChartResult result, String editorPartId) {
     		return openEditor(result, editorPartId, false);
+    	}
     	/**
     	 * Opens an editor specified by its id, computes the specified result then refreshes the editor components.
+    	 *
     	 * @param result
     	 * @param editorPartId
     	 * @param alwaysRecreateEditor force editor creation
     	 * @return
     	 */
     	public static ChartEditor openEditor(ChartResult result, String editorPartId, boolean alwaysRecreateEditor)	{
     	public static ChartEditor openEditor(ChartResult result, String editorPartId, boolean alwaysRecreateEditor) {
     		ChartEditorInput<ChartResult> editorInput = new ChartEditorInput<ChartResult>(result);
     		ChartEditorInput<ChartResult> editorInput = new ChartEditorInput<>(result);
     		editorInput.setAlwaysRecreateEditor(alwaysRecreateEditor);
     		return (ChartEditor) openEditor(editorInput, editorPartId);
+    	}
     	@Override
     	public void updateResultFromEditor() {
     		// does nothing by default
+    	}
     	/**
     	 * Synchronizes the editor with the chart result.
     	 * Synchronizes the editor with the chart result.
     	 * Dedicated to dynamically change the editor components values from the stored result data.
     	 */
     	public abstract void updateEditorFromChart(boolean update);
-...
     		// check that the charts engine used for the result matches the SWT components provider otherwise find a suitable components provider
     		// and recreate new ChartCoomposite and ChartComponent
     		if(this.getResult().getChartsEngine() != this.swtChartsComponentsProvider.getChartsEngine())	{
     		if (this.getResult().getChartsEngine() != this.swtChartsComponentsProvider.getChartsEngine()) {
     			Log.finest("ChartEditor.updateEditorFromResult(): result charts engine  = " + this.getResult().getChartsEngine().getName() + " / Editor charts engine = " + this.swtChartsComponentsProvider.getChartsEngine().getName() + "."); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     			Log.finest("ChartEditor.updateEditorFromResult(): result charts engine  = " + this.getResult().getChartsEngine().getName() + " / Editor charts engine = " + this.swtChartsComponentsProvider //$NON-NLS-1$ //$NON-NLS-2$
     					.getChartsEngine().getName() + ".");  //$NON-NLS-1$
     			this.swtChartsComponentsProvider = SWTChartsComponentsProvider.getComponentsProvider(this.getResult().getChartsEngine());
     			this.swtChartsComponentsProvider.setChartsEngine(this.getResult().getChartsEngine());
     			Log.finest("ChartEditor.updateEditorFromResult(): charts engine used to create the chart does not match the editor one. The SWT components provider has been changed to match it: " + this.getSWTChartsComponentsProvider() + "."); //$NON-NLS-1$ //$NON-NLS-2$
     			Log.finest("ChartEditor.updateEditorFromResult(): charts engine used to create the chart does not match the editor one. The SWT components provider has been changed to match it: " + this //$NON-NLS-1$
     					.getSWTChartsComponentsProvider() + ".");  //$NON-NLS-1$
     			// recreating the chart composite
     			Composite parent = this.chartComposite.getParent();
-...
     			this.chartComposite.setLayoutData(gd);
     			parent.layout();
+    		}
     		boolean needInit = (this.chartComposite.getChartComponent() == null) && (this.getResult().getChart() != null);
     		// loading chart
-...
     		// FIXME: this code should be moved in ChartComposite.loadChart()?
     		if(needInit)	{
     		if (needInit) {
     			this.onInit();
+    		}
     		// sublcass updating
     		this.updateEditorFromChart(update);
+    	}
     	/**
     	 * Method called if the editor needs initialization (if the chart component has not yet been created and if the chart is not null) and dedicated to be override by subclasses if needed to do some process after the initialization.
     	 * Method called if the editor needs initialization (if the chart component has not yet been created and if the chart is not null) and dedicated to be override by subclasses if needed to do some
     	 * process after the initialization.
     	 */
     	protected void onInit()	{
     	protected void onInit() {
     		// nothing to do
+    	}
-...
     	 * Activates the chart editor context.
     	 * The context is used, for example, to enable keyboard shortcut only for ChartEditor.
     	 */
     	public void activateContext()	{
     		IContextService contextService = (IContextService)getSite().getService(IContextService.class);
     		if(contextService != null)	{
     	public void activateContext() {
     		IContextService contextService = getSite().getService(IContextService.class);
     		if (contextService != null) {
     			this.contextActivationToken = contextService.activateContext(CONTEXT_ID_CHART_EDITOR);
     			Log.finest(TXMCoreMessages.bind("ChartEditor.activateContext(): context activated (token = {0}).", this.contextActivationToken)); //$NON-NLS-1$
+    		}
     		else	{
     		else {
     			Log.finest("ChartEditor.activateContext(): context activation falied."); //$NON-NLS-1$
+    		}
+    	}
     	/**
     	 * Deactivates the chart editor context.
     	 * The context is used, for example, to enable keyboard shortcut only for ChartEditor.
     	 */
     	public void deactivateContext()	{
     		IContextService contextService = (IContextService)getSite().getService(IContextService.class);
     		if(contextService != null)	{
     	public void deactivateContext() {
     		IContextService contextService = getSite().getService(IContextService.class);
     		if (contextService != null) {
     			contextService.deactivateContext(this.contextActivationToken);
     			Log.finest(TXMCoreMessages.bind("ChartEditor.deactivateContext(): context deactivated (token = {0}).", this.contextActivationToken)); //$NON-NLS-1$
+    		}
     		else	{
     		else {
     			Log.finest("ChartEditor.activateContext(): context deactivation failed."); //$NON-NLS-1$
+    		}
+    	}
     	@Override
     	public void setFocus() {
     		// FIXME: SJ: old code, temporary disabled
     		// Debug
     		Log.finest("ChartEditor.setFocus(): giving focus to chart composite..."); //$NON-NLS-1$
     		this.parent.setFocus();
     		//super.setFocus();
     //
     		//this.chartComposite.setFocus();
     //
     //
     		// super.setFocus();
     		//
     		// this.chartComposite.setFocus();
     		//
     		//
     		// SJ: new code
     		//super.setFocus();
     		// super.setFocus();
+    	}
     	public void onPartActivated()	{
     	public void onPartActivated() {
     		Log.finest("+++++ ChartEditor.onPartActivated(): " + this.getResult());
     		this.activateContext();
+    	}
     	public void onPartDeactivated()	{
     	public void onPartDeactivated() {
     		Log.finest("----- ChartEditor.onPartDeactivated(): " + this.getResult());
     		this.deactivateContext();
+    	}
     	/**
     	 * Convenience method the get the casted linked editor input.
+    	 *
     	 * @return the editorInput
     	 */
     	@Override
     	public ChartEditorInput<T> getEditorInput() {
     		return (ChartEditorInput) super.getEditorInput();
+    	}
     	/**
     	 * Gets the chart drawing area composite.
+    	 *
     	 * @return the composite
     	 */
     	public ChartComposite getComposite() {
     		return this.chartComposite;
+    	}
     	/**
     	 * Resets the chart view (zoom, pan, rotation).
     	 */
     	public void resetView() {
     		this.chartComposite.resetView();
+    	}
     	/**
     	 *  Clears the selected items in chart.
     	 * Clears the selected items in chart.
     	 */
     	public void clearChartItemsSelection()	{
     	public void clearChartItemsSelection() {
     		this.chartComposite.clearChartItemsSelection();
+    	}
     	/**
     	 * Zooms the chart view at x and y coordinates.
+    	 *
     	 * @param x
     	 * @param y
     	 * @param zoomIn
     	 */
     	public void zoom(double x, double y, boolean zoomIn)	{
     	public void zoom(double x, double y, boolean zoomIn) {
     		this.chartComposite.zoom(x, y, zoomIn);
+    	}
     	/**
     	 * Pans the chart view.
+    	 *
     	 * @param chartComponent
     	 * @param srcX
     	 * @param srcY
-...
     	 * @param dstY
     	 * @param panFactor
     	 */
     	public void pan(double srcX, double srcY, double dstX, double dstY, double panFactor)	{
     	public void pan(double srcX, double srcY, double dstX, double dstY, double panFactor) {
     		this.chartComposite.pan(srcX, srcY, dstX, dstY, panFactor);
+    	}
-...
     	/**
     	 * Copy the current chart view to clipboard.
     	 */
     	public void copyChartViewToClipboard()	{
     	public void copyChartViewToClipboard() {
     		try {
     			this.chartComposite.copyChartViewToClipboard();
+    		}
-...
     			Log.finest("ChartEditor.copyChartViewToClipboard(): nothing done, the chart has not yet been computed."); //$NON-NLS-1$
+    		}
+    	}
     	/**
     	 * Loads the chart from the chart object stored into the composite.
+    	 *
     	 * @param resetView
     	 * @param clearChartItemsSelection
     	 */
     	public void loadChart()	{
     	public void loadChart() {
     		getSite().getShell().getDisplay().syncExec(new Runnable() {
     			@Override
     			public void run() {
     				chartComposite.loadChart(
     						getResult().needsToResetView(),
     						getResult().needsToResetView(),
     						getResult().needsToClearItemsSelection(),
     						getResult().needsToSquareOff());
+    			}
-...
     	 * Implementations using a Composite to embed AWT/Swing components should manually call this.chartComposite.dispose() in the redefined method.
     	 */
     	@Override
     	public void dispose()	{
     	public void dispose() {
     		if (this.chartComposite != null && !this.chartComposite.isDisposed()) {
     			this.chartComposite.dispose();
+    		}
     		super.dispose();
+    	}
     	/**
     	 * Returns the tool bar of this editor.
+    	 *
     	 * @return the toolBar
     	 */
     	public ChartEditorToolBar getToolBar() {
     		return chartToolBar;
+    	}
     	/**
     	 * Returns the advanced tool bar of this editor.
+    	 *
     	 * @return
     	 */
     	public AdvancedChartEditorToolBar getAdvancedToolBar()	{
     	public AdvancedChartEditorToolBar getAdvancedToolBar() {
     		return this.advancedChartToolBar;
+    	}
     	/**
     	 * Gets the chart type. A same result can be drawn as multiple chart types (eg. pie, bar, etc.).
+    	 *
     	 * @return
     	 */
     	public String getChartType()	{
     	public String getChartType() {
     		return this.getResult().getChartType();
+    	}
     	/**
     	 * Returns the chart associated with the editor.
+    	 *
     	 * @return
     	 */
     	public Object getChart()	{
     	public Object getChart() {
     		return this.getResult().getChart();
+    	}
     	/**
     	 * Returns the chart components provider associated with the editor.
+    	 *
     	 * @return
     	 */
     	public SWTChartsComponentsProvider getSWTChartsComponentsProvider()	{
     	public SWTChartsComponentsProvider getSWTChartsComponentsProvider() {
     		return this.swtChartsComponentsProvider;
+    	}
     	/**
     	 * Gets the charts engine used by the result.
+    	 *
     	 * @return
     	 */
     	public ChartsEngine getChartsEngine()	{
     	public ChartsEngine getChartsEngine() {
     		return this.getResult().getChartsEngine();
+    	}
     	/**
     	 * Exports the current view of the chart editor in the specified file.
+    	 *
-...
     	 * @param fileFormat
     	 * @return
     	 */
     	public File exportView(File file, String fileFormat)	{
     	public File exportView(File file, String fileFormat) {
     		return this.chartComposite.exportView(file, fileFormat);
+    	}
     	/**
     	 * Returns the export formats supported by the implementation of the <code>ChartComposite</code> for exporting the current the view.
+    	 *
     	 * @return
     	 */
     	public ArrayList<String> getEditorSupportedExportFileFormats()	{
     	public ArrayList<String> getEditorSupportedExportFileFormats() {
     		return this.chartComposite.getEditorSupportedExportFileFormats();
+    	}
     	/**
     	 * Gets the parent multipages editor part if exists.
+    	 *
     	 * @return the parentMultiPagesEditor
     	 */
     	public MultiPageEditorPart getParentMultiPagesEditor() {
     		return parentMultiPagesEditor;
+    	}
     	/**
     	 * Sets the specified multipages editor part as parent of this one.
+    	 *
     	 * @param parentMultiPagesEditor the parentMultiPagesEditor to set
     	 */
     	public void setParentMultiPagesEditor(TXMMultiPageEditor parentMultiPagesEditor) {
     		this.parentMultiPagesEditor = parentMultiPagesEditor;
+    	}
     	/**
     	 * To check whether this editor was already opened when calling openEditor().
+    	 *
     	 * @return the wasAlreadyOpened
     	 */
     	public boolean wasAlreadyOpened() {
     		return wasAlreadyOpened;
+    	}
     	/**
     	 * To check whether this editor was already opened when calling openEditor().
+    	 *
     	 * @param wasAlreadyOpened the wasAlreadyOpened to set
     	 */
     	public void setWasAlreadyOpened(boolean wasAlreadyOpened) {
     		this.wasAlreadyOpened = wasAlreadyOpened;
+    	}
     	/**
     	 * Checks whatever the chart composite has the focus or not.
+    	 *
     	 * @return <code>true</code> if the chart composite has the focus otherwise <code>false</code>
     	 */
     	public boolean hasFocus()	{
     	public boolean hasFocus() {
     		return this.chartComposite.hasFocus();
+    	}
     	/**
     	 * Gets the chart composite.
+    	 *
     	 * @return the chartComposite
     	 */
     	public ChartComposite getChartComposite() {
-...
     	/**
     	 * Gets the chart toolbar.
+    	 *
     	 * @return the chartToolBar
     	 */
     	public ChartEditorToolBar getChartToolBar() {
     		return chartToolBar;
+    	}
     	@Override
     	public T getResult()	{
     	public T getResult() {
     		return (T) this.getEditorInput().getResult();
+    	}
+    }
     	@Override
     	public void close() {
     		super.close();
     		// FIXME: SJ: temporary work around to close a multipage editor from one of this editor page
     		if (this.parentMultiPagesEditor != null) {
     			this.getSite().getShell().getDisplay().syncExec(new Runnable() {
     				@Override
     				public void run() {
     					getSite().getPage().closeEditor(parentMultiPagesEditor, false);
+    				}
     			});
+    		}
+    	}
+    }

     package org.txm.annotation.kr.rcp.commands;
     import java.util.ArrayList;
     import java.util.Set;
     import org.eclipse.core.commands.AbstractHandler;
     import org.eclipse.core.commands.ExecutionEvent;
-...
     import org.eclipse.jface.dialogs.MessageDialog;
     import org.eclipse.jface.viewers.ISelection;
     import org.eclipse.jface.viewers.IStructuredSelection;
     import org.eclipse.osgi.util.NLS;
     import org.eclipse.swt.widgets.Display;
     import org.eclipse.swt.widgets.MessageBox;
     import org.eclipse.ui.handlers.HandlerUtil;
     import org.txm.annotation.kr.core.AnnotationManager;
     import org.txm.annotation.kr.core.KRAnnotationEngine;
     import org.txm.core.results.TXMResult;
     import org.txm.rcp.TXMWindows;
     import org.txm.rcp.commands.CloseEditorsUsing;
     import org.txm.rcp.commands.workspace.UpdateCorpus;
     import org.txm.rcp.editors.ITXMResultEditor;
     import org.txm.rcp.editors.TXMEditor;
     import org.txm.rcp.messages.TXMUIMessages;
     import org.txm.rcp.utils.JobHandler;
     import org.txm.rcp.utils.SWTEditorsUtils;
     import org.txm.rcp.views.corpora.CorporaView;
-...
     import org.txm.utils.logger.Log;
     public class SaveAnnotations extends AbstractHandler {
     	public static final String ID = SaveAnnotations.class.getCanonicalName();
     	@Override
     	public Object execute(ExecutionEvent event) throws ExecutionException {
     		ISelection sel = (IStructuredSelection) HandlerUtil.getCurrentSelection(event);
     		ISelection sel = HandlerUtil.getCurrentSelection(event);
     		if (!(sel instanceof IStructuredSelection)) return null;
     		IStructuredSelection selection = (IStructuredSelection) sel;
     		Object s = selection.getFirstElement();
     		if (!(s instanceof MainCorpus))
     			return null;
-...
     			if (job == null) {
     				return null;
+    			}
     		} catch (Exception e) {
+    		}
     		catch (Exception e) {
     			// TODO Auto-generated catch block
     			e.printStackTrace();
     			return null;
+    		}
     		CorporaView.refresh();
     		return corpus;
+    	}
     	public static JobHandler save(final MainCorpus corpus) throws Exception {
     		final AnnotationManager am = KRAnnotationEngine.getAnnotationManager(corpus);
     		if (am == null) return null; // nothing to do
-...
     		if (!KRAnnotationEngine.needToSaveAnnotations(corpus)) {
     			return null;
+    		}
     		//System.out.println("DISPLAY="+Display.getDefault());
     		// System.out.println("DISPLAY="+Display.getDefault());
     		final Boolean[] doit = new Boolean[1];
     		doit[0] = true;
     		Display.getDefault().syncExec(new Runnable() {
     			@Override
     			public void run() {
     				if (!MessageDialog.openConfirm(Display.getDefault().getActiveShell(), "Before saving annotations...", "All editors using this corpus are going to be closed. Continue ?")) {
     				if (!MessageDialog.openConfirm(Display.getDefault().getActiveShell(), "Before saving annotations...", "All editors using this corpus will going to be closed. Continue?")) {
     					doit[0] = false;
+    				}
+    			}
-...
     			return null;
+    		}
     		JobHandler jobhandler = new JobHandler("Saving annotations of "+corpus) { //$NON-NLS-1$
     		JobHandler jobhandler = new JobHandler(NLS.bind("Saving annotations of {0}", corpus)) {
     			@Override
     			protected IStatus run(IProgressMonitor monitor) {
     				this.runInit(monitor);
     				try {
     					ArrayList<ITXMResultEditor<?>> editors = SWTEditorsUtils.getEditors() ;
     					monitor.beginTask("Closing editors", editors.size());
     					for (ITXMResultEditor<?> editor : editors) {
     						TXMResult result = editor.getResult();
     						if (corpus.equals(result.getFirstParent(MainCorpus.class))) {
     							editor.close();
+    						}
     						monitor.worked(1);
+    					}
     					// close all opened editors of all children corpus
     					SWTEditorsUtils.closeEditors(corpus, true);
     					boolean rez = am.saveAnnotations(monitor);
     					monitor.worked(30);
     					if (rez) {
     						Log.fine("Annotations are saved in XML-TXM files. Updating corpus indexes and editions");
     					} else {
+    					}
     					else {
     						Log.severe("** Error while saving annotations (see logs above).");
+    					}
     				} catch(Exception e) {
     					System.out.println("Error while saving annotations: "+e);
+    				}
     				catch (Exception e) {
     					System.out.println("Error while saving annotations: " + e);
     					Log.printStackTrace(e);
     					return Status.CANCEL_STATUS;
+    				}
     				return Status.OK_STATUS;
+    			}
     		};
     		if (doit[0]) jobhandler.startJob(true);
     		jobhandler.join();
     		return jobhandler;

tmp/org.txm.rcp/src/main/java/org/txm/rcp/editors/imports/CorpusPage.java (revision 2558)
1037	1037	}
1038	1038	}
1039	1039
1040		DeleteObject.closeEditorOf(project, true);
	1040	SWTEditorsUtils.closeEditors(project, true);
1041	1041
1042	1042	ExecuteImportScript.executeScript(project);
1043	1043

     import java.util.Arrays;
     import java.util.HashSet;
     import java.util.List;
     import java.util.Set;
     import java.util.Timer;
     import java.util.TimerTask;
     import org.eclipse.core.runtime.IConfigurationElement;
     import org.eclipse.core.runtime.IProgressMonitor;
-...
     import org.eclipse.core.runtime.jobs.Job;
     import org.eclipse.jface.action.MenuManager;
     import org.eclipse.jface.dialogs.MessageDialog;
     import org.eclipse.jface.dialogs.ProgressMonitorDialog;
     import org.eclipse.jface.operation.IRunnableWithProgress;
     import org.eclipse.jface.viewers.ISelectionProvider;
     import org.eclipse.jface.viewers.IStructuredSelection;
     import org.eclipse.jface.viewers.StructuredSelection;
-...
     import org.txm.searchengine.cqp.ReferencePattern;
     import org.txm.searchengine.cqp.corpus.Property;
     import org.txm.searchengine.cqp.corpus.query.CQLQuery;
     import org.txm.utils.LogMonitor;
     import org.txm.utils.logger.Log;
     /**
-...
     	public final void createPartControl(Composite parent) {
     		try {
     			// since some editor fields need some values of their parent ensure the parent is ready (e.g. Sub-corpus properties in Cooccurrence editor, etc.)
     			// need to set deep, eg. for Partition that must synchronize its Parts (if false, the Parts are not computed)
     			// it does not break the lazy since the children lazy is now determined by the hasBeenComputedOnce state
     			// Runnable job = new Runnable() {
     			//
     			// @Override
     			// public void run() {
     			// // TODO Auto-generated method stub
     			// TXMEditor.this.getResult().getParent().compute(true);
     			// }
     			// };
     			//
     			// BusyIndicator.showWhile(getSite().getShell().getDisplay(), job);
     			// FIXME: SJ: tests to show modal blocking cancelable progression dialog
     			try {
     				if (!this.getResult().getParent().hasBeenComputedOnce()) {
     					IRunnableWithProgress job2 = new IRunnableWithProgress() {
     						@Override
     						public void run(IProgressMonitor monitor) {
     							// TODO Auto-generated method stub
     							TXMEditor.this.getResult().getParent().compute(monitor);
+    						}
     					};
     					ProgressMonitorDialog dialog = new ProgressMonitorDialog(getSite().getShell()) {
     						@Override
     						protected void cancelPressed() {
     							super.cancelPressed();
     							Thread.currentThread().stop();
+    						}
     					};
     					// Trying to display the dialog only after X seconds, not at start so it not appears for short tasks
     					dialog.setOpenOnRun(false);
     					Timer timer = new Timer();
     					timer.schedule(new TimerTask() {
     						protected int elapsedTime = 0;
     						@Override
     						public void run() {
     							elapsedTime += 10;
     							if (elapsedTime > 1000) {
     								Display.getDefault().asyncExec(new Runnable() {
     									@Override
     									public void run() {
     										dialog.open();
+    									}
     								});
     								timer.purge();
     								timer.cancel();
+    							}
+    						}
     					}, 0, 10);
     					// end of test
     					dialog.run(true, true, job2);
+    				}
+    			}
     			catch (ThreadDeath e) {
     				// TODO Auto-generated catch block
     				// e.printStackTrace();
     				CorporaView.refresh();
     				// TODO: SJ: may need to clean some things here
     				this.close();
     				return;
+    			}
     			// JobHandler job3 = new JobHandler(TXMCoreMessages.bind(TXMUIMessages.computing, this.getResult().getParent().getName()), true) {
     			//
     			// @Override
     			// protected IStatus run(IProgressMonitor monitor) {
     			// this.runInit(monitor);
     			// // TODO Auto-generated method stub
     			// TXMEditor.this.getResult().getParent().compute(true);
     			// return Status.OK_STATUS;
     			// }
     			// };
     			// job3.setUser(true);
     			// job3.startJob();
     			// job3.setProperty(IProgressConstants.PROPERTY_IN_DIALOG, true);
     			// IProgressService ps = PlatformUI.getWorkbench().getProgressService();
     			// ps.showInDialog(getSite().getShell(), job3);
     			// ps.runInUI(ps, (IRunnableWithProgress) job3, org.eclipse.core.resources.ResourcesPlugin.getWorkspace().getRoot());
     			// ps.busyCursorWhile((IRunnableWithProgress) job3);
     			// job3.wait();
     			// this.getResult().getParent().compute(true);
     			// TXMResult corpus = this.getResult().getFirstParent(CorpusBuild.class);
     			// if (corpus != null) {
     			// corpus.compute(false);
     			// }
     			this.parent = parent;
     			// disable the rendering while creating the widgets
-...
     	@Override
     	public final void refresh(boolean update) throws Exception {
     		if (this.parent.isDisposed()) return; // nothing to refresh
     		// nothing to refresh
     		if (this.parent.isDisposed()) {
     			return;
+    		}
     		// skip refresh if the part creation has failed
     		if (!createPartControlDoneSucessfully) {
     		if (!this.createPartControlDoneSucessfully) {
     			return;
+    		}
-...
     		// this.getContainer().setRedraw(false);
     		String title = result.getName();
     		if (title.length() > MAX_NAME_LENGTH) { // limit title length
     		// limit tab title length
     		if (title.length() > MAX_NAME_LENGTH) {
     			title = title.substring(0, MAX_NAME_LENGTH - 1) + "...";
+    		}
     		this.setPartName(title);
-...
     		// FIXME: SJ: this code breaks the dirty/chart dirty separation state, eg. if a non electric rendering parameter is changed then the chart is dirty but not the result, need to check this
     		this.setDirty(this.getResult().isDirty());
     		// FIXME: update all open editors of the children result but also of the result itself
     		// FIXME: update all opened editors of the children result but also of the result itself
     		// FIXME: debug
     		Log.finest("TXMEditor.refresh(): " + this.getClass().getSimpleName() + ": synchronizing and refreshing result children opened editors."); //$NON-NLS-1$ //$NON-NLS-2$
     		List<TXMResult> results = this.getResult().getDeepChildren();
     		for (int i = 0; i < results.size(); i++) {
     			ArrayList<ITXMResultEditor<?>> editors = SWTEditorsUtils.getEditors(results.get(i));
     			for (int j = 0; j < editors.size(); j++) {
     				ITXMResultEditor<?> txmEditor = editors.get(j);
     			Set<ITXMResultEditor<TXMResult>> editors = SWTEditorsUtils.getEditors(results.get(i));
     			for (ITXMResultEditor<TXMResult> txmEditor : editors) {
     				if (txmEditor != this
     				// && txmEditor.isDirty()
     				) {
     					// txmEditor.synchronizeResultFromEditor();
     					// FIXME: SJ: need to prove/test this code
     					// recreate all if the parent result is altered
     					// txmEditor.refresh(!this.getResult().isAltered());
     					txmEditor.refresh(true);
+    				}
+    			}
+    		}
-...
     	 */
     	@Override
     	public void close() {
     		close(false);
     		this.close(false);
+    	}

     							r.setDirty();
     							CorporaView.refreshObject(r);
     							System.out.println(NLS.bind("Parameter imported from the {0} file.", outfile));
     							SWTEditorsUtils.refreshEditor(r);
     							SWTEditorsUtils.refreshEditors(r);
+    						}
     					} catch (ThreadDeath td) {
     						return Status.CANCEL_STATUS;

     import org.eclipse.swt.SWT;
     import org.eclipse.swt.widgets.Display;
     import org.eclipse.swt.widgets.MessageBox;
     import org.eclipse.ui.IWorkbenchPage;
     import org.eclipse.ui.IWorkbenchWindow;
     import org.eclipse.ui.handlers.HandlerUtil;
     import org.eclipse.ui.internal.Workbench;
     import org.txm.core.messages.TXMCoreMessages;
     import org.txm.core.results.TXMResult;
     import org.txm.objects.CorpusBuild;
     import org.txm.objects.Project;

... Ce différentiel a été tronqué car il excède la taille maximale pouvant être affichée.

Formats disponibles : Unified diff

Laboratoire ICAR » Plateforme TXM

Révision 2558