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

     	private CQPCorpus subCorpus = null;
     //	/**
     //	 * Unit property.
     //	 */
     //	@Parameter(key=TXMPreferences.UNIT_PROPERTY)
     //	protected Property unitProperty;
     	/**
     	 * Maximum score.
     	 */
-...
     	@Override
     	public boolean loadParameters() {
     		this.lexicalTable = (LexicalTable) this.parent;
     		//this.unitProperty = this.lexicalTable.getProperty();
     		this.lexicalTable.setVMaxFilter(Integer.MAX_VALUE);
     		this.lexicalTable.setVMaxFilter(Integer.MAX_VALUE); // FIXME: useless?
     		return true;
+    	}
-...
     		this.frequencies = null;
     		// recompute the lexical table
     //		if(this.hasParameterChanged(TBXPreferences.UNIT_PROPERTY))	{
     //			this.lexicalTable.setUnitProperty(this.unitProperty);
     //			this.lexicalTable.compute(this);
     //		}
     		// delete the specificities selection chart children since they can not be valid anymore
     		if (this.needsFullRecomputing || this.hasParameterChanged(TBXPreferences.UNIT_PROPERTY))	{
     			this.deleteChildren(SpecificitiesSelection.class);
+    		}
     		// essentially for cascade computing from the parent lexical table
     //		this.unitProperty = this.lexicalTable.getProperty();
     		if (this.lexicalTable.hasBeenComputedOnce())	{
     			SpecificitiesR rSpecificities = new SpecificitiesR(this.lexicalTable.getData());
     			double[][] specIndex = rSpecificities.getScores();

     	 * Gets the selection as a float number.
     	 * @return
     	 */
     	public double getSelectionAsFloat() {
     		return (double) (super.getSelection() / Math.pow(10, this.getDigits()));
     	public float getSelectionAsFloat() {
     		return (float) (super.getSelection() / Math.pow(10, this.getDigits()));
+    	}
     	/**

     	@Override
         public RGB getForeground(Object element) {
     //		if(element instanceof TXMResult && !((TXMResult)element).hasBeenComputedOnce())	{
     //	    	Display display = Display.getCurrent();
     //	    	Color color = display.getSystemColor(SWT.COLOR_DARK_GRAY);
     //	    	return color.getRGB();
     //		}
     		if(TBXPreferences.getInstance().getBoolean(TBXPreferences.EXPERT_USER) && element instanceof TXMResult && !((TXMResult)element).hasBeenComputedOnce())	{
     	    	Display display = Display.getCurrent();
     	    	Color color = display.getSystemColor(SWT.COLOR_DARK_GRAY);
     	    	return color.getRGB();
+    		}
     		// FIXME: DEbug
     //		else if(element instanceof TXMResult && ((TXMResult)element).isDirty())	{
     //	    	Display display = Display.getCurrent();

     import org.eclipse.jface.viewers.SelectionChangedEvent;
     import org.eclipse.swt.events.SelectionEvent;
     import org.eclipse.swt.events.SelectionListener;
     import org.txm.core.preferences.TXMPreferences;
     import org.eclipse.swt.widgets.Spinner;
     import org.txm.core.results.TXMResult;
     import org.txm.rcp.editors.TXMEditor;
     import org.txm.rcp.preferences.RCPPreferences;
-...
     	@Override
     	public void widgetSelected(SelectionEvent e) {
     		this.editor.compute(true);
     		// this method is called on a Spinner even when a key is pressed, that's not what we want, so this test breaks the behavior
     		if(!(e.getSource() instanceof Spinner) || e.stateMask != 0)	{
     			this.editor.compute(true);
+    		}
+    	}
     	@Override

     command.name.3          = Convertir ancien fichier binaire
     command.name.30         = IndexToConcordances
     command.name.31         = Changer la langue
     command.name.32         = Progression
     command.name.32         = Calculer
     command.name.33         = Conserver
     command.name.34         = ExportSVG
     command.name.35         = ComputeCooccurrences

+    	}
     	@Override
     	public boolean compute(IProgressMonitor monitor) throws Exception {
     	public boolean compute(IProgressMonitor monitor) {
     		Log.finest("ChartResult.compute(): computing result of type " + this.getClass() + "...");
     		try {
     			Log.finest("ChartResult.compute(): computing result of type " + this.getClass() + "...");
     		// compute the result if needed
     		if(super.compute(monitor, true))	{
     			// compute the chart
     			return renderChart();
     			// compute the result if needed
     			if(super.compute(monitor, true))	{
     				// compute the chart
     				return renderChart();
+    			}
     			else	{
     				return false;
+    			}
+    		}
     		else	{
     		catch (Exception e) {
     			e.printStackTrace();
     			Log.severe("ChartResult.compute(): Exception occurs during computing.");
     			return false;
+    		}
+    	}

     				//					value = new Property(this.getStringParameterValue(key), Corpus.getCorpus(this));
     				//				}
     				// MD: nope should be done via adapter or extension point "org.txm.searchengine.cqp.core" contributes to
     				// SJ: or better, when the abstraction of Property, etc. will be done, we could implement some extensions as in ChartCreator model to other engines, eg. SearchEngine, that will return
     				// the right class here
     				f.set(this, value);
     				// FIXME: Debug
-...
     	 * @return
     	 * @throws Exception
     	 */
     	public boolean compute() throws Exception {
     	public boolean compute() {
     		return this.compute(null);
+    	}
-...
     	 * @return
     	 * @throws Exception
     	 */
     	public boolean compute(IProgressMonitor monitor) throws Exception {
     	public boolean compute(IProgressMonitor monitor) {
     		return this.compute(monitor, true);
+    	}
-...
     	 * @throws CqiClientExceptio
     	 * @throws IOException
     	 */
     	protected boolean compute(IProgressMonitor monitor, boolean deepComputing) throws Exception {
     	protected boolean compute(IProgressMonitor monitor, boolean deepComputing) {
     		// FIXME: see if this skipComputing tests is still useful? is it possible to directly return instead?
     		// en fait voir ChartResult.compute() if(super.compute(monitor, true, false)), je pense que le prob vient du fait que si on retourne false dans TXMResult.compute() alors renderChart() ne sera pas appelé
     		boolean skipComputing = false;
     		try {
     			// FIXME: see if this skipComputing tests is still useful? is it possible to directly return instead?
     			// en fait voir ChartResult.compute() if(super.compute(monitor, true, false)), je pense que le prob vient du fait que si on retourne false dans TXMResult.compute() alors renderChart() ne sera pas appelé
     			boolean skipComputing = false;
     		this.monitor = monitor;
     			this.monitor = monitor;
     		// TODO THIS IS FUCKING LAZY LINE CODES OH YEAH YOU MAD BRO
     		// 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.parent != null && !(this.parent instanceof Project)) {
     			if (!this.parent.compute(monitor, true)) {
     				Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": failed to compute parent result.");
     			// TODO THIS IS FUCKING LAZY LINE CODES OH YEAH YOU MAD BRO
     			// 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.parent != null && !(this.parent instanceof Project)) {
     				if (!this.parent.compute(monitor, true)) {
     					Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": failed to compute parent result.");
     				return false;
     					return false;
+    				}
+    			}
+    		}
     		boolean d0 = this.isDirty();
     		boolean d1 = this.needsFullRecomputing;
     		boolean d2 = this.isDirtyFromHistory();
     		boolean d3 = this.isDirty();
     		if (!d1 &&
     				!d2 && !d3) {
     			// needsFullRecomputing == true && isDirtyFromHistory == true && isDirty == true
     			Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": result parameters have not changed since last computing, computing skipped.");
     			skipComputing = true;
+    		}
     			boolean d0 = this.isDirty();
     			boolean d1 = this.needsFullRecomputing;
     			boolean d2 = this.isDirtyFromHistory();
     			boolean d3 = this.isDirty();
     			if (!d1 &&
     					!d2 && !d3) {
     				// needsFullRecomputing == true && isDirtyFromHistory == true && isDirty == true
     				Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": result parameters have not changed since last computing, computing skipped.");
     				skipComputing = true;
+    			}
     		if(!skipComputing)	{
     			if(!skipComputing)	{
     			// FIXME: Debug
     			Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": computing result of type " + this.getClass() + "...");
     				// FIXME: Debug
     				Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": computing result of type " + this.getClass() + "...");
     			// Computing requirements test
     			if (!this.canCompute()) {
     				Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": missing or wrong parameters, computing aborted.");
     				return false;
+    			}
     				// Computing requirements test
     				if (!this.canCompute()) {
     					Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": missing or wrong parameters, computing aborted.");
     					return false;
+    				}
     			// Computing
     			if (!this._compute()) {
     				Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": computing failed.");
     				return false;
     				// Computing
     				if (!this._compute()) {
     					Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": computing failed.");
     					return false;
+    				}
+    			}
+    		}
     		// clear the lazy name, no more needed since the object has been computed and getSimpleName() can now work
     		this.lazyName = null;
     			// clear the lazy name, no more needed since the object has been computed and getSimpleName() can now work
     			this.lazyName = null;
     //		// store last used parameters
     //		if (updateLastParameters)	{
-...
     //			TXMPreferences.flush(this);
     //		}
     		if(!skipComputing)	{
     			// store last used parameters
     			this.updateLastParameters();
     			if(!skipComputing)	{
     				// store last used parameters
     				this.updateLastParameters();
     			if (!this.autoSaveParametersFromAnnotations()) {
     				Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": failed to save parameters from annotations for " + this.getName() + ".");
+    			}
     			if (!this.saveParameters()) {
     				Log.severe("TXMResult.compute():" + this.getClass().getSimpleName() + ": failed to save parameters for " + this.getName() + ".");
+    			}
     				if (!this.autoSaveParametersFromAnnotations()) {
     					Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": failed to save parameters from annotations for " + this.getName() + ".");
+    				}
     				if (!this.saveParameters()) {
     					Log.severe("TXMResult.compute():" + this.getClass().getSimpleName() + ": failed to save parameters for " + this.getName() + ".");
+    				}
     			// file persistence flush
     			if (this.mustBePersisted()) {
     				TXMPreferences.flush(this);
+    			}
     			this.dirty = false; // the computing was successful, the result is no more dirty
     			this.hasBeenComputedOnce = true;
     			this.needsFullRecomputing = false;
     			Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": computing of result type " + this.getClass() + " done.");
     			// set the children as dirty since the result has changed
     			for (int i = 0; i < this.children.size(); i++) {
     				this.children.get(i).setDirty();
+    			}
     			// Children cascade computing ; if parent == null this is the Workspace
     			if (deepComputing && parent != null) {
     				Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": cascade computing of " + this.children.size() + " children.");
     				// file persistence flush
     				if (this.mustBePersisted()) {
     					TXMPreferences.flush(this);
+    				}
     				this.dirty = false; // the computing was successful, the result is no more dirty
     				this.hasBeenComputedOnce = true;
     				this.needsFullRecomputing = false;
     				Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": computing of result type " + this.getClass() + " done.");
     				// set the children as dirty since the result has changed
     				for (int i = 0; i < this.children.size(); i++) {
     					// FIXME: may be better to add a member needFullRecomputing in TXMResult?
     //					this.getChild(i).setDirty(); // force recomputing even if some parameters of the result itself have not changed
     					this.children.get(i).setNeedsFullRecomputing(true); // force recomputing even if some parameters of the result itself have not changed
     					// recompute only children that has been opened once
     					//if (child.hasBeenComputedOnce()) {
     					this.children.get(i).compute(monitor, deepComputing);
     					//}
     					this.children.get(i).setDirty();
+    				}
     				// FIXME: SJ: this code generates concurrent modification excpetions when deep computing
     				// here for tests purpose
     				// Children cascade computing ; if parent == null this is the Workspace
     				if (deepComputing && parent != null) {
     					Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": cascade computing of " + this.children.size() + " children.");
     					for (int i = 0; i < this.children.size(); i++) {
     						// FIXME: may be better to add a member needFullRecomputing in TXMResult?
     //					this.getChild(i).setDirty(); // force recomputing even if some parameters of the result itself have not changed
     						this.children.get(i).setNeedsFullRecomputing(true); // force recomputing even if some parameters of the result itself have not changed
     						// recompute only children that has been opened once
     						//if (child.hasBeenComputedOnce()) {
     						this.children.get(i).compute(monitor, deepComputing);
     						//}
+    					}
     					// FIXME: SJ: this code generates concurrent modification excpetions when deep computing
     					// here for tests purpose
     //				for (TXMResult child : this.getChildren()) {
     //					child.setNeedsFullRecomputing(true); // force recomputing even if some parameters of the result itself have not changed
     //					// recompute only children that has been opened once
     //					child.compute(monitor, deepComputing);
     //				}
+    				}
+    			}
+    		}
     		catch (Exception e) {
     			// TODO Auto-generated catch block
     			e.printStackTrace();
     			Log.severe("TXMResult.compute(): Exception occurs during computing.");
     			return false;
+    		}
     		return true;
+    	}
-...
     	public ArrayList<HashMap<String, Object>> getParametersHistory() {
     		return parametersHistory;
+    	}
     	/**
+    	 *
     	 * @return the first parent which visible state is true
     	 */
     	public TXMResult getFirstVisibleParent() {
     		if (parent == null) return null;
     		else if (parent.isVisible()) return parent;
     		else return parent.getFirstVisibleParent();
+    	}
+    }

+    	}
     	@Override
     	public CQPCorpus getParent() {
     		return (CQPCorpus)super.getParent();
+    	}
     	@Override
     	public boolean loadParameters() throws Exception {
     		try {
     			String p = this.getStringParameterValue(TXMPreferences.UNIT_PROPERTY);
-...
+    		}
     		// creating new Lexicon
     		if(lexicon == null || lexicon.getProperty() != property)	{
     		if(lexicon == null || !lexicon.getProperty().getFullName().equals(property.getFullName()))	{
     			lexicon = new Lexicon(corpus);
     			lexicon.setProperty(property);
+    		}
-...
     //		}
     //	}
     	@Override
     	public CQPCorpus getParent() {
     		return (CQPCorpus)super.getParent();
+    	}
     	@Override
     	public String getResultype() {
     		return IndexCoreMessages.LEXICON_RESULT_TYPE;

tmp/org.txm.lexicaltable.core/src/org/txm/lexicaltable/core/functions/LexicalTable.java (revision 1158)
553	553	} catch (Exception e) {
554	554	// TODO Auto-generated catch block
555	555	e.printStackTrace();
	556	return this.getEmptyName();
556	557	}
557	558	return strb.toString();
558	559

Laboratoire ICAR » Plateforme TXM

Révision 1158