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

     import org.txm.rcp.messages.TXMUIMessages;
     import org.txm.rcp.preferences.RCPPreferences;
     import org.txm.rcp.swt.GLComposite;
     import org.txm.rcp.swt.dialog.AdvancedProgressMonitorDialog;
     import org.txm.rcp.swt.dialog.ComputeProgressMonitorDialog;
     import org.txm.rcp.swt.widget.AssistedChoiceQueryWidget;
     import org.txm.rcp.swt.widget.AssistedQueryWidget;
     import org.txm.rcp.swt.widget.FloatSpinner;
-...
     			// FIXME: SJ: Quick'n'dirty fix
     			// without that the result is computed twice, one time when checking the branch is consistent
     			// and another time when calling ediot.compute().
     			// and another time when calling editor.compute().
     			// See if we can do this directly in the editor ?
     			// or pre-compute only the parents and not the result iself ?
     			boolean needComputing = true;
     			// boolean needComputing = true;
     			// since some editor fields need some values of their parent,
     			// ensure the parents branch is ready (e.g. Sub-corpus properties in Cooccurrence editor, etc.)
     			// show modal blocking cancelable progression dialog
     			if (!wasAlreadyOpened && !editorInput.getResult().getParent().hasBeenComputedOnce()) {
     			if (!wasAlreadyOpened
     			// && !editorInput.getResult().getParent().hasBeenComputedOnce()
     			) {
     				try {
     					// AdvancedProgressMonitorDialog dialog = new AdvancedProgressMonitorDialog(window.getShell(), editorInput.getResult().getParent());
     					// FIXME: SJ: finally it may be better to call the current result computing? it will do the parents branch computing but
     					// the main task stays the compute of the result itself, not the parent
     					AdvancedProgressMonitorDialog dialog = new AdvancedProgressMonitorDialog(window.getShell(), editorInput.getResult());
     					ComputeProgressMonitorDialog dialog = new ComputeProgressMonitorDialog(window.getShell(), editorInput.getResult());
     					dialog.runComputingProcess(true);
     					needComputing = false;
     					// needComputing = false;
+    				}
     				// user canceling case
     				catch (InterruptedException e) {
-...
     			if (tmpEditor instanceof TXMEditor) {
     				editor = (TXMEditor<? extends TXMResult>) tmpEditor;
+    			}
     			else if (tmpEditor instanceof TXMMultiPageEditor) {
     				editor = (TXMEditor<? extends TXMResult>) ((TXMMultiPageEditor) tmpEditor).getMainEditorPart();
+    			}
     			else {
     				Log.severe(NLS.bind("Failed to open editor {0}.", editorId)); // $NON-NLS-1$
     				return null;
+    			}
     			if (wasAlreadyOpened) {
     			if (!wasAlreadyOpened) {
+    			}
     			else {
     				// }
     				// else {
     				// TODO until the TXMResult don't know if its parameters are set by the user or by the default preference value, we need to use the AUTO_COMPUTE_ON_EDITOR_OPEN preference
     				// compute the result only if the editor wasn't already opened
     				if (needComputing && (RCPPreferences.getInstance().getBoolean(RCPPreferences.AUTO_COMPUTE_ON_EDITOR_OPEN))) {
     					editor.compute(false);
+    				}
     				else {
     					editor.refresh(false);
+    				}
     				// if (//needComputing &&
     				// (RCPPreferences.getInstance().getBoolean(RCPPreferences.AUTO_COMPUTE_ON_EDITOR_OPEN))) {
     				// editor.compute(false);
     				// }
     				// else {
     				editor.refresh(false);
     				// }
+    			}
+    		}
     		catch (Exception e) {

     package org.txm.rcp.swt.dialog;
     import java.lang.reflect.InvocationTargetException;
     import java.util.Timer;
     import java.util.TimerTask;
     import org.eclipse.core.runtime.IProgressMonitor;
     import org.eclipse.jface.operation.IRunnableWithProgress;
     import org.eclipse.swt.widgets.Composite;
     import org.eclipse.swt.widgets.Display;
     import org.eclipse.swt.widgets.Shell;
     import org.eclipse.ui.internal.progress.ProgressMonitorJobsDialog;
     import org.txm.core.results.TXMResult;
     /**
      * An advanced progress monitor modal dialog managing delay before displaying the window
      * and the forcing of cancel using Thread.stop().
+     *
      * @author sjacquot
+     *
      */
     public class AdvancedProgressMonitorDialog extends ProgressMonitorJobsDialog {
     	/**
     	 * Result.
     	 */
     	protected TXMResult result;
     	/**
     	 * Delay in ms before opening the dialog after starting runnable.
     	 */
     	protected int delayBeforeOpen;
     	/**
     	 * Creates a modal progress monitor dialog.
+    	 *
     	 * @param parent
     	 * @param result
     	 * @param delayBeforeOpen delay in ms before opening the dialog after starting runnable
     	 */
     	public AdvancedProgressMonitorDialog(Shell parent, TXMResult result, int delayBeforeOpen) {
     		super(parent);
     		this.result = result;
     		this.delayBeforeOpen = delayBeforeOpen;
     		this.setOpenOnRun(false);
+    	}
     	/**
     	 * Creates a modal progress monitor dialog.
+    	 *
     	 * @param parent
     	 * @param result
     	 */
     	public AdvancedProgressMonitorDialog(Shell parent, TXMResult result) {
     		this(parent, result, 1000);
+    	}
     	@Override
     	protected void createDetailsButton(Composite parent) {
     		// to not create the "Details" button
+    	}
     	@Override
     	protected void configureShell(final Shell shell) {
     		super.configureShell(shell);
     		// set window title to result start computing message
     		shell.setText(this.result.getComputingStartMessage());
+    	}
     	/**
     	 * Runs the computing process on the stored <code>TXMResult</code>.
+    	 *
     	 * @param cancelable
     	 * @throws InvocationTargetException
     	 * @throws InterruptedException
     	 */
     	public void runComputingProcess(boolean cancelable) throws InvocationTargetException, InterruptedException {
     		IRunnableWithProgress runnable = new IRunnableWithProgress() {
     			@Override
     			public void run(IProgressMonitor monitor) throws InterruptedException {
     				result.compute(monitor, false);
+    			}
     		};
     		this.run(cancelable, runnable);
+    	}
     	/**
     	 * Runs the given <code>IRunnableWithProgress</code>.
+    	 *
     	 * @param cancelable
     	 * @param runnable
     	 * @throws InvocationTargetException
     	 * @throws InterruptedException
     	 */
     	public void run(boolean cancelable, IRunnableWithProgress runnable) throws InvocationTargetException, InterruptedException {
     		this.run(true, cancelable, runnable);
+    	}
     	@Override
     	public void run(boolean fork, boolean cancelable, IRunnableWithProgress runnable) throws InvocationTargetException, InterruptedException {
     		// manage the dialog open delay
     		Timer timer = new Timer();
     		timer.schedule(new TimerTask() {
     			protected int elapsedTime = 0;
     			@Override
     			public void run() {
     				this.elapsedTime += 10;
     				if (this.elapsedTime > delayBeforeOpen) {
     					Display.getDefault().asyncExec(new Runnable() {
     						@Override
     						public void run() {
     							open();
+    						}
     					});
     					this.cancel();
     					timer.purge();
     					timer.cancel();
+    				}
+    			}
     		}, 0, 10);
     		super.run(fork, cancelable, runnable);
+    	}
     	@Override
     	protected void cancelPressed() {
     		this.result.getComputingThread().stop();
     		super.cancelPressed();
+    	}
+    }

     package org.txm.rcp.swt.dialog;
     import java.lang.reflect.InvocationTargetException;
     import java.util.Timer;
     import java.util.TimerTask;
     import org.eclipse.core.runtime.IProgressMonitor;
     import org.eclipse.jface.operation.IRunnableWithProgress;
     import org.eclipse.swt.widgets.Composite;
     import org.eclipse.swt.widgets.Display;
     import org.eclipse.swt.widgets.Shell;
     import org.eclipse.ui.internal.progress.ProgressMonitorJobsDialog;
     import org.txm.core.results.TXMResult;
     /**
      * An advanced progress monitor modal dialog managing delay before displaying the window
      * and the forcing of cancel using Thread.stop().
+     *
      * @author sjacquot
+     *
      */
     public class ComputeProgressMonitorDialog extends ProgressMonitorJobsDialog {
     	/**
     	 * Result.
     	 */
     	protected TXMResult result;
     	/**
     	 * Delay in ms before opening the dialog after starting runnable.
     	 */
     	protected int delayBeforeOpen;
     	/**
     	 * Creates a modal progress monitor dialog.
+    	 *
     	 * @param parent
     	 * @param result
     	 * @param delayBeforeOpen delay in ms before opening the dialog after starting runnable
     	 */
     	public ComputeProgressMonitorDialog(Shell parent, TXMResult result, int delayBeforeOpen) {
     		super(parent);
     		this.result = result;
     		this.delayBeforeOpen = delayBeforeOpen;
     		this.setOpenOnRun(false);
+    	}
     	/**
     	 * Creates a modal progress monitor dialog.
+    	 *
     	 * @param parent
     	 * @param result
     	 */
     	public ComputeProgressMonitorDialog(Shell parent, TXMResult result) {
     		this(parent, result, 1000);
+    	}
     	@Override
     	protected void createDetailsButton(Composite parent) {
     		// to not create the "Details" button
+    	}
     	@Override
     	protected void configureShell(final Shell shell) {
     		super.configureShell(shell);
     		// set window title to result start computing message
     		shell.setText(this.result.getComputingStartMessage());
+    	}
     	/**
     	 * Runs the computing process on the stored <code>TXMResult</code>.
+    	 *
     	 * @param cancelable
     	 * @throws InvocationTargetException
     	 * @throws InterruptedException
     	 */
     	public void runComputingProcess(boolean cancelable) throws InvocationTargetException, InterruptedException {
     		IRunnableWithProgress runnable = new IRunnableWithProgress() {
     			@Override
     			public void run(IProgressMonitor monitor) throws InterruptedException {
     				result.compute(monitor, false);
+    			}
     		};
     		this.run(cancelable, runnable);
+    	}
     	/**
     	 * Runs the given <code>IRunnableWithProgress</code>.
+    	 *
     	 * @param cancelable
     	 * @param runnable
     	 * @throws InvocationTargetException
     	 * @throws InterruptedException
     	 */
     	public void run(boolean cancelable, IRunnableWithProgress runnable) throws InvocationTargetException, InterruptedException {
     		this.run(true, cancelable, runnable);
+    	}
     	@Override
     	public void run(boolean fork, boolean cancelable, IRunnableWithProgress runnable) throws InvocationTargetException, InterruptedException {
     		// manage the dialog open delay
     		Timer timer = new Timer();
     		timer.schedule(new TimerTask() {
     			protected int elapsedTime = 0;
     			@Override
     			public void run() {
     				this.elapsedTime += 10;
     				if (this.elapsedTime > delayBeforeOpen) {
     					Display.getDefault().asyncExec(new Runnable() {
     						@Override
     						public void run() {
     							open();
+    						}
     					});
     					this.cancel();
     					timer.purge();
     					timer.cancel();
+    				}
+    			}
     		}, 0, 10);
     		super.run(fork, cancelable, runnable);
+    	}
     	@Override
     	protected void cancelPressed() {
     		this.result.getComputingThread().stop();
     		super.cancelPressed();
+    	}
+    }

tmp/org.txm.ca.rcp/src/org/txm/ca/rcp/editors/CAEditor.java (revision 2648)
181	181	this.setPageText(editorIndex, this.names.get(i));
182	182	}
183	183
184		caFactorialMapEditorPart.compute(false);
	184	// caFactorialMapEditorPart.compute(false);
	185	// caFactorialMapEditorPart.refresh(false);
	186	eigenvalues.compute();
185	187
186	188	}
187	189	catch (Exception e1) {

     import org.txm.rcp.editors.TXMEditor;
     import org.txm.rcp.handlers.BaseAbstractHandler;
     import org.txm.rcp.messages.TXMUIMessages;
     import org.txm.rcp.swt.dialog.AdvancedProgressMonitorDialog;
     import org.txm.rcp.swt.dialog.ComputeProgressMonitorDialog;
     import org.txm.rcp.utils.JobHandler;
     import org.txm.rcp.views.corpora.CorporaView;
     import org.txm.searchengine.cqp.CQPSearchEngine;
-...
     					CQPCorpus corpus = (CQPCorpus) selection;
     					if (!corpus.hasBeenComputedOnce()) {
     						AdvancedProgressMonitorDialog dialog = new AdvancedProgressMonitorDialog(HandlerUtil.getActiveWorkbenchWindowChecked(event).getShell(), corpus);
     						ComputeProgressMonitorDialog dialog = new ComputeProgressMonitorDialog(HandlerUtil.getActiveWorkbenchWindowChecked(event).getShell(), corpus);
     						dialog.runComputingProcess(true);
+    					}

     import org.txm.rcp.editors.TXMEditor;
     import org.txm.rcp.handlers.BaseAbstractHandler;
     import org.txm.rcp.messages.TXMUIMessages;
     import org.txm.rcp.swt.dialog.AdvancedProgressMonitorDialog;
     import org.txm.rcp.swt.dialog.ComputeProgressMonitorDialog;
     import org.txm.rcp.utils.JobHandler;
     import org.txm.rcp.views.corpora.CorporaView;
     import org.txm.searchengine.cqp.core.preferences.PartitionPreferences;
-...
     					CQPCorpus corpus = (CQPCorpus) selection;
     					if (!corpus.hasBeenComputedOnce()) {
     						AdvancedProgressMonitorDialog dialog = new AdvancedProgressMonitorDialog(HandlerUtil.getActiveWorkbenchWindowChecked(event).getShell(), corpus);
     						ComputeProgressMonitorDialog dialog = new ComputeProgressMonitorDialog(HandlerUtil.getActiveWorkbenchWindowChecked(event).getShell(), corpus);
     						dialog.runComputingProcess(true);
+    					}

Laboratoire ICAR » Plateforme TXM

Révision 2648