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

     /**
+     *
      * @author sjacquot
+     *
      */
     public class SpecificitiesCoreMessages extends NLS {
     	private static final String BUNDLE_NAME = "org.txm.specificities.core.messages.messages"; //$NON-NLS-1$

     import java.util.Arrays;
     import java.util.List;
     import org.txm.chartsengine.core.results.ChartResult;
     import org.txm.core.results.TXMParameters;
     import org.txm.core.results.TXMResult;
     import org.txm.lexicaltable.core.functions.LexicalTable;
     import org.txm.lexicon.core.corpusengine.cqp.Lexicon;
     import org.txm.searchengine.cqp.clientExceptions.CqiClientException;
-...
     import org.txm.statsengine.core.utils.ArrayIndex;
     import org.txm.statsengine.core.utils.CheckArray;
     import org.txm.statsengine.r.core.RWorkspace;
     import org.txm.utils.logger.Log;
     /**
      * Hold specificities computation result.
      * Holds specificities computation result.
+     *
      * @author mdecorde
      * @author sloiseau
+     *
      */
     public class Specificities extends ChartResult  {
     public class Specificities extends TXMResult  {
     	public static int MAXSPECIF = 1000;
-...
     	@Deprecated
     	private BufferedWriter writer;
     	protected int pMaxScore;
     	/**
     	 * The selected type names to focus on.
     	 * Specificities.
+    	 *
     	 * @param table the table
     	 * @return the specificities result
     	 * @throws CqiClientException the cqi client exception
     	 * @throws StatException the stat exception
     	 */
     	protected String[] selectedTypeNames;
     	public Specificities(LexicalTable table, int maxScore)	throws CqiClientException, StatException {
     		super(table);
     		this.table = table;
     		this.pMaxScore = maxScore;
+    	}
     	/**
     	 * The selected part names to focus on.
     	 */
     	protected String[] selectedPartNames;
     	/**
     	 * The selected specificities indices to focus on.
     	 */
     	protected double[][] selectedSpecificitiesIndex;
     	private int pMaxScore;
     	@Override
     	protected boolean _compute(boolean update) throws Exception {
     		SpecificitiesR si = new SpecificitiesR(table.getData());
-...
     //			System.out.println("prop="+table.getProperty());
     			init(symbol, specIndex, table, Arrays
     					.asList(table.getRowNames().asStringsArray()), Arrays.asList(table.getColNames().asStringsArray()), table.getProperty().getName(), this.pMaxScore);
     		} else {
+    		}
     		else {
     			init(si.getSymbol(), specIndex, table, Arrays
     					.asList(table.getRowNames().asStringsArray()), Arrays.asList(table.getColNames().asStringsArray()),
     					"TLNONAME: " + table.getProperty().getName(), this.pMaxScore); //$NON-NLS-1$
-...
     		return true;
+    	}
     //	/**
     //	 * Compute the specificity index for all the cells of a complete lexical
     //	 * table, as defined by a {@link Partition} and a {@link Property}.
     //	 *
     //	 * This may be used for extracting, for all part, the forms the most or the
     //	 * less specif ic.
     //	 *
     //	 * @param partition the partition
     //	 * @param analysisProperty the analysis property
     //	 * @param formFocus the form focus
     //	 * @param partsFocus the parts focus
     //	 * @param Fmin the fmin
     //	 * @return the specificites result
     //	 * @throws CqiClientException the cqi client exception
     //	 * @throws StatException the stat exception
     //	 */
     //	public Specificities(Partition partition, Property analysisProperty, int Fmin, int maxScore) throws Exception {
     //		this(LexicalTableFactory.getLexicalTable(partition, analysisProperty, Fmin), maxScore);
     //
     //		if (partition.getParts().size() < 2) {
     //			throw new IllegalArgumentException(SpecificitiesCoreMessages.ComputeError_NEED_AT_LEAST_2_PARTS);
     //		}
     //	}
     	/**
     	 * Specificites.
+    	 *
     	 * @param table the table
     	 * @return the specificites result
     	 * @throws CqiClientException the cqi client exception
     	 * @throws StatException the stat exception
     	 */
     	public Specificities(LexicalTable table, int maxScore)	throws CqiClientException, StatException {
     		super(table);
     		if (table.getNColumns() < 2) {
     			throw new IllegalArgumentException(SpecificitiesCoreMessages.ComputeError_NEED_AT_LEAST_2_PARTS);
+    		}
     		this.table = table;
     		this.pMaxScore = maxScore; // TODO: move this to setParamters(...)
+    	}
     //	/**
     //	 * Specificites.
     //	 *
     //	 * @param corpus the corpus
     //	 * @param subcorpus the subcorpus
     //	 * @param property the property
     //	 * @return the specificites result
     //	 * @throws CqiClientException the cqi client exception
     //	 * @throws StatException the stat exception
     //	 * @throws REXPMismatchException
     //	 * @throws RserveException
     //	 */
     //	public Specificities(Corpus corpus, Subcorpus subcorpus, Property property, int maxScore) throws Exception {
     //		super(corpus);
     //		Lexicon totalFrequencies = Lexicon.getLexicon(corpus, property);
     //		Lexicon subFrequencies = Lexicon.getLexicon(subcorpus, property);
     //
     //		//System.out.println("Send corpus vector");
     //		Vector totalFSymbol;
     //		Vector subFSymbol;
     //		try {
     //			totalFSymbol = totalFrequencies.asVector();
     //			subFSymbol = subFrequencies.asVector();
     //		} catch (StatException e) {
     //			throw new RWorkspaceException(e);
     //		}
     //
     //		SpecificitiesR si = new SpecificitiesR(totalFSymbol, subFSymbol);
     //		double[][] specIndex = si.getScores();
     //
     //		init(si.getSymbol(), specIndex, totalFrequencies, subFrequencies, corpus.getName()+"\\"+subcorpus.getName(), maxScore);
     //	}
     //
     //	/**
     //	 * Instantiates a new specificities result : for subcorpus specificities.
     //	 *
     //	 * @param symbol the symbol
     //	 * @param specIndex the spec index
     //	 * @param lexicon the lexicon
     //	 * @param subLexicon the sub lexicon
     //	 * @param name the name
     //	 */
     //	protected void init(String symbol, double[][] specIndex, Lexicon lexicon, Lexicon subLexicon, String name, int maxScore) {
     //
     //		//super(subLexicon.getCorpus());
     //		this.corpus = subLexicon.getCorpus();
     //		this.symbol = symbol;
     //		this.indices = specIndex;
     //
     //		this.lexicon = lexicon;
     //		this.subLexicon = subLexicon;
     //		this.corpus = lexicon.getCorpus();
     //		this.subCorpus = subLexicon.getCorpus();
     //		this.name = name;
     //
     //		int MAX = MAXSPECIF;
     //		int MIN = -MAXSPECIF;
     //
     //		if (maxScore > 0) {
     //			MAX = maxScore;
     //			MIN = -maxScore;
     //		}
     //		for (int i = 0 ; i < indices.length ; i++) {
     //			for (int j = 0 ; j < indices[i].length ; j++) {
     //				if (indices[i][j] > MAX) {
     //					indices[i][j] = MAX;
     //				} else if (indices[i][j] < MIN) {
     //					indices[i][j] = MIN;
     //				}
     //			}
     //		}
     //
     //		this.table = null;
     //	}
     	/**
     	 * Instantiates a new specificities result.
+    	 *
     	 * @param symbol the symbol
-...
     	 * @param maxScore if abs(score) > maxScore -> score = +/- maxScore
     	 * @throws StatException the stat exception
     	 */
     	protected void init(String symbol, double[][] specIndex, LexicalTable table,
     			List<String> typeFocus, List<String> partFocus, String name, int maxScore)
     					throws StatException {
     	protected void init(String symbol, double[][] specIndex, LexicalTable table, List<String> typeFocus, List<String> partFocus, String name, int maxScore) throws StatException {
     		this.table = table;
     		this.symbol = symbol;
-...
     						SpecificitiesCoreMessages.bind(SpecificitiesCoreMessages.ComputeError_FOUND_AND_WANTED_ROWS_MISMATCH, typeFocus.size(), specIndex.length));
+    			}
     			rowindex = ArrayIndex.getIndex(
     					table.getRowNames().asStringsArray(), typeFocus
     					.toArray(new String[] {}));
     			rowindex = ArrayIndex.getIndex(table.getRowNames().asStringsArray(), typeFocus.toArray(new String[] {}));
     			for (int i : rowindex) {
     				if (i == -1) {
     					throw new IllegalArgumentException(
     							SpecificitiesCoreMessages.SpecificitesResult_6);
     					throw new IllegalArgumentException(SpecificitiesCoreMessages.SpecificitesResult_6);
+    				}
+    			}
+    		}
-...
     	 */
     	public String[] getTypeNames() throws StatException {
     		if (table != null) {
     			return (rownames != null && rownames.size() != 0) ? rownames
     					.toArray(new String[] {}) : table.getRowNames()
     					.asStringsArray();
     			return (rownames != null && rownames.size() != 0) ? rownames.toArray(new String[] {}) : table.getRowNames().asStringsArray();
     		} else {
     			return lexicon.getForms();
+    		}
-...
     	public String[] getPartShortNames() throws StatException {
     		//		System.out.println("get col names: "+table);
     		//		System.out.println("colnames: "+colnames);
     		if (colnames != null && colnames.size() > 0)
     		if (colnames != null && colnames.size() > 0) {
     			return colnames.toArray(new String[]{});
+    		}
     		else if (table != null) {
     			// return (colnames != null && colnames.size() != 0) ?
     			// colnames.toArray(new String[]{}) :
-...
     			 * parts.get(i).getShortName(); }
     			 */
     			return table.getColNames().asStringsArray();
     		} else {
     			if (this.subCorpus != null)
     				return new String[] { this.subCorpus.getName(),
     					this.corpus.getName() + " \\ " + this.subCorpus.getName() }; //$NON-NLS-1$
     		} else if (this.subCorpus != null) {
     			return new String[] { this.subCorpus.getName(),this.corpus.getName() + " \\ " + this.subCorpus.getName() }; //$NON-NLS-1$
+    		}
     		return new String[0];
+    	}
-...
+    		}
+    	}
     	/**
     	 * To txt.
+    	 *
     	 * @param outfile the outfile
     	 * @param encoding the encoding
     	 * @param colseparator the colseparator
     	 * @param txtseparator the txtseparator
     	 * @return true, if successful
     	 * @throws StatException the stat exception
     	 */
     	@Override
     	public boolean toTxt(File outfile, String encoding, String colseparator, String txtseparator) throws StatException {
     		// NK: Declared as class attribute to perform a clean if the operation is interrupted
-...
     		return true;
+    	}
     	/**
     	 * Gets the symbol.
+    	 *
     	 * @return the symbol
     	 */
     	public String getSymbol() {
     		return symbol;
+    	}
     	/**
     	 * Gets the sorted part indexes.
+    	 *
     	 * @return the sorted part indexes
     	 */
     	public int[] getSortedPartIndexes() {
     		try {
     			int[] indexes = new int[this.getNbrPart()];
     			String[] partsname = this.getPartShortNames().clone();
     			for (int i = 0; i < this.getNbrPart(); i++) {
     				indexes[i] = i;
+    			}
     			for (int i = 0; i < this.getNbrPart(); i++) {
     				int imin = i;
     				for (int j = i; j < this.getNbrPart(); j++) {
     					if (partsname[imin].compareTo(partsname[j]) > 0) {
     						imin = j;
+    					}
+    				}
     				String tmp = partsname[i];
     				partsname[i] = partsname[imin];
     				partsname[imin] = tmp;
     				int tmp2 = indexes[i];
     				indexes[i] = indexes[imin];
     				indexes[imin] = tmp2;
+    			}
     			return indexes;
     		} catch (StatException e) {
     			org.txm.utils.logger.Log.printStackTrace(e);
+    		}
     		return new int[0];
+    	}
     	/**
     	 * Sets the corpus.
+    	 *
     	 * @param subcorpus2 the new corpus
-...
+    		}
+    	}
     	/**
     	 * @return the selectedTypeNames
     	 */
     	public String[] getSelectedTypeNames() {
     		return selectedTypeNames;
+    	}
     	/**
     	 * @param selectedTypeNames the selectedTypeNames to set
     	 */
     	public void setSelectedTypeNames(String[] selectedTypeNames) {
     		this.selectedTypeNames = selectedTypeNames;
+    	}
     	/**
     	 * @return the selectedPartNames
     	 */
     	public String[] getSelectedPartNames() {
     		return selectedPartNames;
+    	}
     	/**
     	 * @param selectedPartNames the selectedPartNames to set
     	 */
     	public void setSelectedPartNames(String[] selectedPartNames) {
     		this.selectedPartNames = selectedPartNames;
+    	}
     //	/**
     //	 * Gets the symbol.
     //	 *
     //	 * @return the symbol
     //	 */
     //	public String getSymbol() {
     //		return symbol;
     //	}
     	/**
     	 * @return the selectedSpecificitiesIndex
     	 */
     	public double[][] getSelectedSpecificitiesIndex() {
     		return selectedSpecificitiesIndex;
+    	}
     	/**
     	 * @param selectedSpecificitiesIndex the selectedSpecificitiesIndex to set
     	 */
     	public void setSelectedSpecificitiesIndex(double[][] selectedSpecificitiesIndex) {
     		this.selectedSpecificitiesIndex = selectedSpecificitiesIndex;
+    	}
     //	/**
     //	 * Gets the sorted part indexes.
     //	 *
     //	 * @return the sorted part indexes
     //	 */
     //	public int[] getSortedPartIndexes() {
     //
     //		try {
     //			int[] indexes = new int[this.getNbrPart()];
     //			String[] partsname = this.getPartShortNames().clone();
     //			for (int i = 0; i < this.getNbrPart(); i++) {
     //				indexes[i] = i;
     //			}
     //
     //			for (int i = 0; i < this.getNbrPart(); i++) {
     //				int imin = i;
     //				for (int j = i; j < this.getNbrPart(); j++) {
     //					if (partsname[imin].compareTo(partsname[j]) > 0) {
     //						imin = j;
     //					}
     //				}
     //				String tmp = partsname[i];
     //				partsname[i] = partsname[imin];
     //				partsname[imin] = tmp;
     //
     //				int tmp2 = indexes[i];
     //				indexes[i] = indexes[imin];
     //				indexes[imin] = tmp2;
     //			}
     //			return indexes;
     //		} catch (StatException e) {
     //			org.txm.utils.logger.Log.printStackTrace(e);
     //		}
     //		return new int[0];
     //	}
     	@Override
     	public String getName() {
     		// FIXME: to define
     //		if (this.specificitiesResult.getLexicalTable()!= null && this.specificitiesResult.getLexicalTable().getPartition() != null)	{
     //			setPartName(this.specificitiesResult.getLexicalTable().getPartition().getName()+": "+specificitiesResult.getName()); //$NON-NLS-1$
     //		} else if (spinput.getSubcorpus() != null) {
     //			setPartName(spinput.getSubcorpus().getName()+": "+specificitiesResult.getName()); //$NON-NLS-1$
     //		} else {
     //			setPartName(specificitiesResult.getName());
     //		}
     		return name;
+    	}
-...
     	@Override
     	public String getSimpleName() {
     		// FIXME: to define
     		return this.getName();
+    	}
     	@Override
     	public String getDetails() {
     		// FIXME: to define
     		return this.getName();
+    	}
     	@Override
     	public boolean canCompute() {
     		return table != null;
     		if(this.table == null) {
     			return false;
+    		}
     		if (table.getNColumns() < 2) {
     			Log.severe(SpecificitiesCoreMessages.ComputeError_NEED_AT_LEAST_2_PARTS);
     			return false;
+    		}
     		return true;
+    	}
     	@Override
     	public boolean setParameters(TXMParameters parameters) {
     		return false;
     	/**
     	 * @param maxScore the pMaxScore to set
     	 */
     	public void setMaxScore(int maxScore) {
     		this.pMaxScore = maxScore;
+    	}
+    }

     /**
+     *
      */
     package org.txm.specificities.core.functions;
     import java.io.File;
     import org.txm.chartsengine.core.results.ChartResult;
     /**
      * A selection from a Specificities result dedicated to export or chart creation.
      * @author sjacquot
+     *
      */
     public class SpecificitiesSelection extends ChartResult {
     	/**
     	 * The selected type names to focus on.
     	 */
     	protected String[] selectedTypeNames;
     	/**
     	 * The selected part names to focus on.
     	 */
     	protected String[] selectedPartNames;
     	/**
     	 * The selected specificities indices to focus on.
     	 */
     	protected double[][] selectedSpecificitiesIndex;
     	/**
     	 * Creates an empty SpecificitiesSelection.
     	 * @param parent
     	 */
     	public SpecificitiesSelection(Specificities parent) {
     		super(parent);
+    	}
     	/**
     	 * @return the selectedTypeNames
     	 */
     	public String[] getSelectedTypeNames() {
     		return selectedTypeNames;
+    	}
     	/**
     	 * @param selectedTypeNames the selectedTypeNames to set
     	 */
     	public void setSelectedTypeNames(String[] selectedTypeNames) {
     		this.selectedTypeNames = selectedTypeNames;
+    	}
     	/**
     	 * @return the selectedPartNames
     	 */
     	public String[] getSelectedPartNames() {
     		return selectedPartNames;
+    	}
     	/**
     	 * @param selectedPartNames the selectedPartNames to set
     	 */
     	public void setSelectedPartNames(String[] selectedPartNames) {
     		this.selectedPartNames = selectedPartNames;
+    	}
     	/**
     	 * @return the selectedSpecificitiesIndex
     	 */
     	public double[][] getSelectedSpecificitiesIndex() {
     		return selectedSpecificitiesIndex;
+    	}
     	/**
     	 * @param selectedSpecificitiesIndex the selectedSpecificitiesIndex to set
     	 */
     	public void setSelectedSpecificitiesIndex(double[][] selectedSpecificitiesIndex) {
     		this.selectedSpecificitiesIndex = selectedSpecificitiesIndex;
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.core.results.TXMResult#getName()
     	 */
     	@Override
     	public String getName() {
     		String name = "";
     		for (int i = 0; i < selectedTypeNames.length; i++) {
     			name += selectedTypeNames[i] + " ";
+    		}
     		return name;
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.core.results.TXMResult#getSimpleName()
     	 */
     	@Override
     	public String getSimpleName() {
     		// TODO Auto-generated method stub
     		return this.getName();
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.core.results.TXMResult#getDetails()
     	 */
     	@Override
     	public String getDetails() {
     		// TODO Auto-generated method stub
     		return this.getName();
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.core.results.TXMResult#clean()
     	 */
     	@Override
     	public void clean() {
     		//does nothing
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.core.results.TXMResult#canCompute()
     	 */
     	@Override
     	public boolean canCompute() throws Exception {
     		return this.parent != null;
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.core.results.TXMResult#_compute(boolean)
     	 */
     	@Override
     	protected boolean _compute(boolean update) throws Exception {
     		// TODO Auto-generated method stub
     		return true;
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.core.results.TXMResult#toTxt(java.io.File, java.lang.String, java.lang.String, java.lang.String)
     	 */
     	@Override
     	public boolean toTxt(File outfile, String encoding, String colseparator, String txtseparator) throws Exception {
     		// TODO Auto-generated method stub
     		return false;
+    	}
+    }

     import org.txm.chartsengine.jfreechart.core.renderers.interfaces.IRendererWithItemSelection;
     import org.txm.chartsengine.jfreechart.core.themes.base.ExtendedNumberAxis;
     import org.txm.chartsengine.jfreechart.core.themes.base.SymbolAxisBetweenTicks;
     import org.txm.core.preferences.TXMPreferences;
     import org.txm.core.results.TXMResult;
     import org.txm.specificities.core.functions.Specificities;
     import org.txm.specificities.core.functions.SpecificitiesSelection;
     import org.txm.specificities.core.messages.SpecificitiesCoreMessages;
     import org.txm.specificities.core.preferences.SpecificitiesPreferences;
     /**
      * Creates a specificities chart from the specified <code>SpecificitesResult</code> result.
      * Creates a bar chart from the specified <code>SpecificitiesSelection</code> result.
      * @author sjacquot
+     *
      */
     public class JFCSpecificitiesBarChartCreator extends JFCChartCreator {
     	public JFCSpecificitiesBarChartCreator() {
+    	}
     	@Override
     	public JFreeChart createChart(TXMResult result) {
     		Specificities specificitiesResult = (Specificities) result;
     		SpecificitiesSelection specificitiesSelection = (SpecificitiesSelection) result;
     		// parameters
     		boolean drawBars = result.getBooleanParameterValue(SpecificitiesPreferences.CHART_DRAW_BARS);
-...
             if(drawBars)	{
     			// Create the bar chart
     	        chart = this.getChartsEngine().createXYBarChart(dataset, specificitiesResult.getName(), SpecificitiesCoreMessages.Charts_X_AXIS_LABEL, SpecificitiesCoreMessages.Charts_Y_AXIS_LABEL, true, false);
     	        chart = this.getChartsEngine().createXYBarChart(dataset, specificitiesSelection.getName(), SpecificitiesCoreMessages.Charts_X_AXIS_LABEL, SpecificitiesCoreMessages.Charts_Y_AXIS_LABEL, true, false);
+            }
             else	{
     			// Create the line chart
     	        chart = this.getChartsEngine().createXYLineChart(dataset, specificitiesResult.getName(), SpecificitiesCoreMessages.Charts_X_AXIS_LABEL, SpecificitiesCoreMessages.Charts_Y_AXIS_LABEL,
     	        chart = this.getChartsEngine().createXYLineChart(dataset, specificitiesSelection.getName(), SpecificitiesCoreMessages.Charts_X_AXIS_LABEL, SpecificitiesCoreMessages.Charts_Y_AXIS_LABEL,
     	        		true, false, true, true, true, false, false);
+            }
-...
     	@Override
     	public void updateChart(Object chart, TXMResult result) {
     		Specificities specificitiesResult = (Specificities) result;
     		SpecificitiesSelection specificitiesSelection = (SpecificitiesSelection) result;
     		JFreeChart jfcChart = (JFreeChart) chart;
     		// freeze rendering
-...
     		// Transpose the data set
     		if(result.getBooleanParameterValue(SpecificitiesPreferences.CHART_TRANSPOSE))	{
     	        xAxisSymbols = new String[specificitiesResult.getSelectedTypeNames().length];
     	        xAxisSymbols = new String[specificitiesSelection.getSelectedTypeNames().length];
     			for(int i = 0; i < specificitiesResult.getSelectedPartNames().length; i++) {
     				XYSeries series = new XYSeries(specificitiesResult.getSelectedPartNames()[i]);
     			for(int i = 0; i < specificitiesSelection.getSelectedPartNames().length; i++) {
     				XYSeries series = new XYSeries(specificitiesSelection.getSelectedPartNames()[i]);
     				dataset.addSeries(series);
     				for(int j = 0; j < specificitiesResult.getSelectedTypeNames().length; j++) {
     					series.add(j, specificitiesResult.getSelectedSpecificitiesIndex()[j][i]);
     				for(int j = 0; j < specificitiesSelection.getSelectedTypeNames().length; j++) {
     					series.add(j, specificitiesSelection.getSelectedSpecificitiesIndex()[j][i]);
     					// Add X axis symbol
     					xAxisSymbols[j] = specificitiesResult.getSelectedTypeNames()[j];
     					xAxisSymbols[j] = specificitiesSelection.getSelectedTypeNames()[j];
+    				}
+    			}
+    		}
     		else {
     	        xAxisSymbols = new String[specificitiesResult.getSelectedPartNames().length];
     	        xAxisSymbols = new String[specificitiesSelection.getSelectedPartNames().length];
     			for(int i = 0; i < specificitiesResult.getSelectedTypeNames().length; i++) {
     			for(int i = 0; i < specificitiesSelection.getSelectedTypeNames().length; i++) {
     				XYSeries series = new XYSeries(specificitiesResult.getSelectedTypeNames()[i]);
     				XYSeries series = new XYSeries(specificitiesSelection.getSelectedTypeNames()[i]);
     				dataset.addSeries(series);
     				for(int j = 0; j < specificitiesResult.getSelectedPartNames().length; j++) {
     					series.add(j, specificitiesResult.getSelectedSpecificitiesIndex()[i][j]);
     				for(int j = 0; j < specificitiesSelection.getSelectedPartNames().length; j++) {
     					series.add(j, specificitiesSelection.getSelectedSpecificitiesIndex()[i][j]);
     					// Add X axis symbol
     					xAxisSymbols[j] = specificitiesResult.getSelectedPartNames()[j];
     					xAxisSymbols[j] = specificitiesSelection.getSelectedPartNames()[j];
+    				}
+    			}
+    		}
-...
     	@Override
     	public Class getResultDataClass() {
     		return Specificities.class;
     		return SpecificitiesSelection.class;
+    	}

     import org.txm.chartsengine.core.preferences.ChartsEnginePreferences;
     import org.txm.chartsengine.r.core.RChartCreator;
     import org.txm.core.preferences.TXMPreferences;
     import org.txm.core.results.TXMResult;
     import org.txm.specificities.core.functions.Specificities;
     import org.txm.specificities.core.functions.SpecificitiesSelection;
     import org.txm.specificities.core.messages.SpecificitiesCoreMessages;
     import org.txm.specificities.core.preferences.SpecificitiesPreferences;
     import org.txm.statsengine.core.data.Matrix;
-...
     import org.txm.utils.logger.Log;
     /**
      * Creates a partition dimensions bar chart from the specified <code>Partition</code> result.
      * Creates a bar chart from the specified <code>SpecificitiesSelection</code> result.
      * @author sjacquot
+     *
      */
-...
     		try {
     			Specificities specificitiesResult = (Specificities) result;
     			SpecificitiesSelection specificitiesSelection = (SpecificitiesSelection) result;
     			// parameters
     			boolean transpose = result.getBooleanParameterValue(SpecificitiesPreferences.CHART_TRANSPOSE);
-...
     			// TODO: should filter max and min here
     			// specIndex
     			Matrix spec = new DoubleMatrix(specificitiesResult.getSelectedSpecificitiesIndex());
     			Vector types = new VectorImpl(specificitiesResult.getSelectedTypeNames());
     			Vector parts = new VectorImpl(specificitiesResult.getSelectedPartNames());
     			Matrix spec = new DoubleMatrix(specificitiesSelection.getSelectedSpecificitiesIndex());
     			Vector types = new VectorImpl(specificitiesSelection.getSelectedTypeNames());
     			Vector parts = new VectorImpl(specificitiesSelection.getSelectedPartNames());
     			RWorkspace rw = RWorkspace.getRWorkspaceInstance();
     			rw.eval("rownames(" + spec.getSymbol() + ") <- " + types.getSymbol() + ";"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-...
     			// Title
     			String title = "";
     			if(result.getBooleanParameterValue(ChartsEnginePreferences.SHOW_TITLE))	{
     				title = specificitiesResult.getName();
     				title = specificitiesSelection.getName();
+    			}
-...
     			int itemsCount = 0;
     			 // to put one color per part
     			if (transpose) {
     				itemsCount = specificitiesResult.getSelectedPartNames().length;
     				itemsCount = specificitiesSelection.getSelectedPartNames().length;
+    			}
     			// to put one color per word
     			else	{
     				itemsCount = specificitiesResult.getSelectedTypeNames().length;
     				itemsCount = specificitiesSelection.getSelectedTypeNames().length;
+    			}
     			String[] colors = new String[itemsCount];
-...
     	@Override
     	public Class getResultDataClass() {
     		return Specificities.class;
     		return SpecificitiesSelection.class;
+    	}
+    }

+    	}
     	@Override
     	public boolean setParameters(TXMParameters parameters) {
     		return false;
+    	}
     	@Override
     	protected boolean _compute(boolean update) throws StatException {
     		itable = table.getData();
     		colNames = itable.getColNames().asStringsArray();

tmp/org.txm.specificities.core/src/org/txm/functions/contrasts/Specificites2.java (revision 544)
54	54	return itable != null;
55	55	}
56	56
57		@Override
58		public boolean setParameters(TXMParameters parameters) {
59		return false;
60		}
61	57	}

tmp/org.txm.specificities.core/src/org/txm/functions/contrasts/RelativeFrequency.java (revision 544)
63	63	return itable != null;
64	64	}
65	65
66		@Override
67		public boolean setParameters(TXMParameters parameters) {
68		return false;
69		}
70	66	}

     					monitor.worked(45);
     					lexicalTableAble.getParent().addResult(table);
     					lexicalTableAble.getParent().addChild(table);
     					monitor.worked(5);
-...
     							return Status.CANCEL_STATUS;
+    						}
     						partition.addResult(table);
     						partition.addChild(table);
     						monitor.worked(5);
-...
     					if (monitor.isCanceled() || table == null)
     						return Status.CANCEL_STATUS;
     					firstIndex.addResult(table);
     					firstIndex.addChild(table);
     					monitor.worked(5);
     					monitor.subTask(RCPMessages.ComputeLexicalTable_10);

     	CA ca = new CA(discours_dates, word_property, 0 ,9999999)
     	ca.stepLexicalTable();
     	ca.stepSortTableLexical();
     	ca.stepCompute()
     	ca.compute()
     	ca.toSVGFactorialMap(new File(exporttestdir,"cadates"), true, true)
     	ca.toSVGSingularValues(new File(exporttestdir,"cadates_singularvalues"))
     	if (firstExecution == 0)
-...
     	print " AFC"
     	time = System.currentTimeMillis();
     	CA ca2 = new CA(table);
     	ca2.stepCompute()
     	ca2.compute()
     	ca2.toSVGFactorialMap(new File(exporttestdir,"cadates"), true, true)
     	ca2.toSVGSingularValues(new File(exporttestdir,"cadates_singularvalues"))
     	if (firstExecution == 0)

     	 * @param symbol the symbol
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public LexicalTableImpl(LexicalTableImpl table, String symbol)
     			throws RWorkspaceException {
     	public LexicalTableImpl(LexicalTableImpl table, String symbol) throws RWorkspaceException {
     		super(symbol);
     		initSortedIndex();
+    	}
-...
     	 * @param symbol the symbol
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public LexicalTableImpl(String symbol)
     			throws RWorkspaceException {
     	public LexicalTableImpl(String symbol) throws RWorkspaceException {
     		super(symbol);
+    	}
     	/**
+    	 *
     	 * @param symbol
     	 * @param corpusLexicon
     	 * @param subcorpusLexicon
     	 * @throws StatException
     	 */
     	public LexicalTableImpl(String symbol, Lexicon corpusLexicon, Lexicon subcorpusLexicon) throws StatException {
     		super(symbol);
     		RWorkspace rw = RWorkspace.getRWorkspaceInstance();
-...
     			BufferedReader reader = new BufferedReader(new FileReader(f));
     			int i = 0;
     			while(reader.readLine() != null) i++;
     			while(reader.readLine() != null) {
     				i++;
+    			}
     			return i;
     		} catch (Exception e) { return 0; }
+    	}

     import java.util.List;
     import java.util.Map;
     import org.txm.core.results.TXMResult;
     import org.txm.lexicaltable.core.statsengine.data.ILexicalTable;
     import org.txm.lexicaltable.core.statsengine.r.data.LexicalTableImpl;
     import org.txm.lexicon.core.corpusengine.cqp.Lexicon;
     import org.txm.searchengine.cqp.clientExceptions.CqiClientException;
-...
     import org.txm.searchengine.cqp.corpus.Partition;
     import org.txm.searchengine.cqp.corpus.Property;
     import org.txm.searchengine.cqp.corpus.Subcorpus;
     import org.txm.statsengine.core.StatException;
     import org.txm.statsengine.core.data.Vector;
     import org.txm.statsengine.r.core.exceptions.RWorkspaceException;
     public class LexicalTableFactory {
-...
+    	 *
     	 * @param partition the partition
     	 * @param analysisProperty the analysis property
     	 * @param Fmin the fmin
     	 * @param fMin the fmin
     	 * @param vmax
     	 * @return the lexical table
     	 * @throws CqiClientException the cqi client exception
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public static final LexicalTable getLexicalTable(Partition partition,
     			Property analysisProperty, int Fmin) throws Exception {
     	public static final LexicalTable getLexicalTable(Partition partition, Property analysisProperty, int fMin) throws Exception {
     		//long time = System.currentTimeMillis();
     		List<Lexicon> lexicons = new ArrayList<Lexicon>();
     		// Set<String> allLexiconEntry = new HashSet<String>();
-...
     		ArrayList<String> filteredForms = new ArrayList<String>();
     		//create a copy and filter line with Fmin;
     		for (int i = 0 ; i < ll.getFreq().length ; i++) {
     			if (ll.getFreq()[i] >= Fmin) {
     			if (ll.getFreq()[i] >= fMin) {
     				filteredForms.add(ll.getForms()[i]);
+    			}
+    		}
-...
     			for (int j = 0; j < freqs.length; j++) {
     				id = entries2index.get(ents[j]);
     				// if (entriesFreqs[id] >= 2)
     				if (id != null)
     				if (id != null) {
     					mat[id][i] = freqs[j]; //mat.setQuick(id, i, freqs[j]);
+    				}
+    			}
+    		}
     		//System.out.println("time build matrix "+(System.currentTimeMillis()-time));
-...
     		//System.out.println("mat size " + mat.rows());
     		//System.out.println("mat columns " + mat.columns());
     		LexicalTableImpl itable = new LexicalTableImpl(mat, filteredForms.toArray(new String[]{}), partition.getPartShortNames()
     				.toArray(new String[] {}));
     		LexicalTableImpl iTable = new LexicalTableImpl(mat, filteredForms.toArray(new String[]{}), partition.getPartShortNames().toArray(new String[] {}));
     		LexicalTable table = new LexicalTable(partition,
     				analysisProperty, Fmin, itable);
     		LexicalTable table = new LexicalTable(partition, analysisProperty, fMin, iTable);
     		//System.out.println("time build table lexical "+(System.currentTimeMillis()-time));
     		return table;
+    	}
     	/**
+    	 *
     	 * @param subcorpus
     	 * @param property
     	 * @return
     	 * @throws Exception
     	 */
     	public static LexicalTable getLexicalTable(Subcorpus subcorpus, Property property) throws Exception {
     		LexicalTable table = new LexicalTable(subcorpus, property);
     		return table;
     		return new LexicalTable(subcorpus, property);
+    	}
+    }

     import java.util.List;
     import java.util.Map;
     import org.txm.core.results.TXMParameters;
     import org.txm.core.results.TXMResult;
     import org.txm.index.core.functions.Index;
     import org.txm.index.core.functions.Line;
     import org.txm.lexicaltable.core.messages.LexicalTableCoreMessages;
     import org.txm.lexicaltable.core.preferences.LexicalTablePreferences;
     import org.txm.lexicaltable.core.statsengine.data.ILexicalTable;
     import org.txm.lexicaltable.core.statsengine.r.data.LexicalTableImpl;
     import org.txm.lexicon.core.corpusengine.cqp.Lexicon;
-...
     import org.txm.statsengine.core.data.Vector;
     import org.txm.statsengine.r.core.RWorkspace;
     import org.txm.statsengine.r.core.exceptions.RWorkspaceException;
     import org.txm.utils.logger.Log;
     /**
      * ILexicalTable logic + TXMResult management methods
-...
     public class LexicalTable extends TXMResult {
     	public static Integer LEXICALTABLE_COUNTER = new Integer(1);
     	public static String SYMBOL_BASE = "LexicalTable_";
     	public static String SYMBOL_BASE = "LexicalTable_"; //$NON-NLS-1$
     	/** the statengine data object */
     	ILexicalTable data;
-...
+    	}
     	/**
+    	 *
     	 * @param partition
     	 * @param analysisProperty
     	 * @param fmin
     	 * @param itable
     	 */
     	public LexicalTable(Partition partition, Property analysisProperty, int fmin, LexicalTableImpl itable) {
     		super(partition);
     		this.pProperty = analysisProperty;
     		this.data = itable;
+    	}
     	public LexicalTable(Subcorpus subcorpus) throws Exception {
     		this(subcorpus, subcorpus.getProperty("word")); //$NON-NLS-1$
+    	}
     	public LexicalTable(Subcorpus subcorpus, Property property) throws Exception {
     		super(subcorpus);
     		this.pProperty = property;
+    	}
     	/**
     	 * Creates the lexical table.
+    	 *
     	 * @param vocabularies the vocabularies
-...
     	 * @return the lexical table
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	protected void _computeForIndex(List<Index> vocabularies)
     			throws RWorkspaceException {
     	protected void _computeForIndex(List<Index> vocabularies) throws RWorkspaceException {
     		System.out.println(LexicalTableCoreMessages.LexicalTableImpl_1 + vocabularies);
     		Index partindex = vocabularies.get(0);// FRIGO
     		Partition partition = partindex.getPartition(); // the Index is computed on a partition
     		if (!partindex.isComputedWithPartition())
     		if (!partindex.isComputedWithPartition()) {
     			throw new IllegalArgumentException("Vocabularies are not computed with a partition. Aborting.");
+    		}
     		this.pProperty = partindex.getProperties().get(0);
-...
     					Line ll = alllines.get(l.getSignature());
     					int[] c1 = ll.getFrequencies();
     					int[] c2 = l.getFrequencies();
     					for (int i = 0; i < c1.length; i++)
     					for (int i = 0; i < c1.length; i++) {
     						c2[i] += c1[i];
+    					}
     					ll.setCounts(c2, 0.0f);
     				} else
+    				}
     				else {
     					alllines.put(l.toString(), l);
+    				}
+    			}
+    		}
-...
     			rownames.add(l.toString());
+    		}
     		int extra = 0;
     		if (pUseAllOccurrences)
     		if (pUseAllOccurrences) {
     			extra = 1;
+    		}
     		String[] entries = new String[alllines.size() + extra];
-...
     		//System.out.println("mat size : ["+(rownames.size() + extra)+"]["+colnames.size()+"]");
     		//System.out.println("rownames size : "+rownames.size());
     		//System.out.println("colnames size : "+colnames.size());
     		this.data = new LexicalTableImpl(mat, rownames.toArray(new String[] {}), colnames
     				.toArray(new String[] {}));
     		this.data = new LexicalTableImpl(mat, rownames.toArray(new String[] {}), colnames.toArray(new String[] {}));
+    	}
     	/**
+    	 *
     	 * @param partition
     	 * @param analysisProperty
     	 * @param fmin
     	 * @param itable
     	 */
     	public LexicalTable(Partition partition, Property analysisProperty, int fmin, LexicalTableImpl itable) {
     		super(partition);
     		this.pProperty = analysisProperty;
     		this.data = itable;
+    	}
     	public LexicalTable(Subcorpus subcorpus) throws Exception {
     		this(subcorpus, subcorpus.getProperty("word"));
+    	}
     	public LexicalTable(Subcorpus subcorpus, Property property) throws Exception {
     		super(subcorpus);
     		this.pProperty = property;
+    	}
     	@Override
     	protected boolean _compute(boolean update) throws Exception {
-...
     		return false;
+    	}
     	/**
+    	 *
     	 * @param partition
     	 * @throws Exception
     	 */
     	protected void _computeForPartition(Partition partition) throws Exception {
     		//long time = System.currentTimeMillis();
     		List<Lexicon> lexicons = new ArrayList<Lexicon>();
-...
     			for (int j = 0; j < freqs.length; j++) {
     				id = entries2index.get(ents[j]);
     				// if (entriesFreqs[id] >= 2)
     				if (id != null)
     				if (id != null) {
     					mat[id][i] = freqs[j]; //mat.setQuick(id, i, freqs[j]);
+    				}
+    			}
+    		}
     		//System.out.println("time build matrix "+(System.currentTimeMillis()-time));
-...
     		//System.out.println("mat size " + mat.rows());
     		//System.out.println("mat columns " + mat.columns());
     		data = new LexicalTableImpl(mat, filteredForms.toArray(new String[]{}), partition.getPartShortNames()
     				.toArray(new String[] {}));
     		data = new LexicalTableImpl(mat, filteredForms.toArray(new String[]{}), partition.getPartShortNames().toArray(new String[] {}));
+    	}
     	@Override
     	public boolean canCompute() {
     		return true; // can be computed on partition or corpus
     		return this.parent != null; // can be computed on partition or corpus
+    	}
     	@Override
-...
     		if (parent instanceof Partition) return ((Partition)parent).getCorpus();
     		if (parent instanceof Index) return ((Index)parent).getCorpus();
     		else return null;
     		// FIXME: prove this above method, it should work, but....
     		//return this.getFirstCorpusParent();
+    	}
     	public ILexicalTable getData() {
-...
     	@Override
     	public String getName() {
     		return this.getPartition().getSimpleName() + ":" + this.getSimpleName(); //$NON-NLS-1$
     		try {
     			return this.getPartition().getSimpleName() + ":" + this.getSimpleName(); //$NON-NLS-1$
+    		}
     		catch(Exception e) {
+    		}
     		return "";
+    	}
     	public int getNColumns() {
-...
     	/**
     	 * see LexicalTablePreferences.PROPERTY, LexicalTablePreferences.F_MIN, LexicalTablePreferences.V_MAX and LexicalTablePreferences.USEALLOCCURENCES
     	 */
     	@Override
     	public boolean setParameters(TXMParameters parameters) {
     		try {
     			if (parameters.get(LexicalTablePreferences.PROPERTY) != null) {
     				Object o = parameters.get(LexicalTablePreferences.PROPERTY);
     				if (o instanceof Property) this.pProperty = (Property) o;
     				else if (o instanceof String) this.pProperty = this.getCorpus().getProperty(o.toString());
+    			}
     			if (parameters.get(LexicalTablePreferences.F_MIN) != null) {
     				Object o = parameters.get(LexicalTablePreferences.F_MIN);
     				if (o instanceof Integer) this.pFminFilter = (Integer)o;
     				else if (o instanceof String) this.pFminFilter = Integer.parseInt(o.toString());
+    			}
     			if (parameters.get(LexicalTablePreferences.V_MAX) != null) {
     				Object o = parameters.get(LexicalTablePreferences.V_MAX);
     				if (o instanceof Integer) this.pVMaxFilter = (Integer)o;
     				else if (o instanceof String) this.pVMaxFilter = Integer.parseInt(o.toString());
+    			}
     			if (parameters.get(LexicalTablePreferences.USEALLOCCURENCES) != null) {
     				Object o = parameters.get(LexicalTablePreferences.USEALLOCCURENCES);
     				if (o instanceof Boolean) this.pUseAllOccurrences = (Boolean)o;
     				else if (o instanceof Integer) this.pUseAllOccurrences = (Integer)o > 0;
     				else if (o instanceof String) this.pUseAllOccurrences = Boolean.parseBoolean(o.toString());
+    			}
     //	public boolean setParameters(TXMParameters parameters) {
     //		try {
     //			if (parameters.get(LexicalTablePreferences.PROPERTY) != null) {
     //				Object o = parameters.get(LexicalTablePreferences.PROPERTY);
     //				if (o instanceof Property) this.pProperty = (Property) o;
     //				else if (o instanceof String) this.pProperty = this.getCorpus().getProperty(o.toString());
     //			}
     //			if (parameters.get(LexicalTablePreferences.F_MIN) != null) {
     //				Object o = parameters.get(LexicalTablePreferences.F_MIN);
     //				if (o instanceof Integer) this.pFminFilter = (Integer)o;
     //				else if (o instanceof String) this.pFminFilter = Integer.parseInt(o.toString());
     //			}
     //			if (parameters.get(LexicalTablePreferences.V_MAX) != null) {
     //				Object o = parameters.get(LexicalTablePreferences.V_MAX);
     //				if (o instanceof Integer) this.pVMaxFilter = (Integer)o;
     //				else if (o instanceof String) this.pVMaxFilter = Integer.parseInt(o.toString());
     //			}
     //			if (parameters.get(LexicalTablePreferences.USEALLOCCURENCES) != null) {
     //				Object o = parameters.get(LexicalTablePreferences.USEALLOCCURENCES);
     //				if (o instanceof Boolean) this.pUseAllOccurrences = (Boolean)o;
     //				else if (o instanceof Integer) this.pUseAllOccurrences = (Integer)o > 0;
     //				else if (o instanceof String) this.pUseAllOccurrences = Boolean.parseBoolean(o.toString());
     //			}
     //
     //			dirty = true;
     //		} catch (Exception e) {
     //			System.out.println("Error while setting LexicalTable parameters: "+e.getLocalizedMessage());
     //			Log.printStackTrace(e);
     //			return false;
     //		}
     //		return true;
     //	}
     			dirty = true;
     		} catch (Exception e) {
     			System.out.println("Error while setting LexicalTable parameters: "+e.getLocalizedMessage());
     			Log.printStackTrace(e);
     			return false;
+    		}
     		return true;
+    	}
     	public boolean toTxt(File outfile, String encoding, String colseparator, String txtseparator) {
     		return data.toTxt(outfile, encoding, colseparator, txtseparator);
+    	}

     		dirty = true;
+    	}
     	@Override
     	public boolean setParameters(TXMParameters parameters) {
     		try {
     			Boolean columns = this.getBooleanParameterValue(AHCPreferences.COLUMNS_COMPUTING);
     			String metric = this.getStringParameterValue(AHCPreferences.METRIC);
     			Integer nCluster = this.getIntParameterValue(AHCPreferences.N_CLUSTERS);
     			String method = this.getStringParameterValue(AHCPreferences.METHOD);
     			this.setParameters(columns, metric, nCluster, method);
     		} catch(Exception e) {
     			System.out.println("Error while setting CAH parameters: "+e.getLocalizedMessage());
     			return false;
+    		}
     		return true;
     	public void loadParameters() {
     		this.setParameters(
     				this.getBooleanParameterValue(AHCPreferences.COLUMNS_COMPUTING),
     				this.getStringParameterValue(AHCPreferences.METRIC),
     				this.getIntParameterValue(AHCPreferences.N_CLUSTERS),
     				this.getStringParameterValue(AHCPreferences.METHOD)
     				);
+    	}
     //	@Override
     //	public void loadParameters() {
     //		this.setParameters(
     //				this.getBooleanParameterValue(AHCPreferences.COLUMNS_COMPUTING),
     //				this.getStringParameterValue(AHCPreferences.METRIC),
     //				this.getIntParameterValue(AHCPreferences.N_CLUSTERS),
     //				this.getStringParameterValue(AHCPreferences.METHOD)
     //				);
     //	}
     	@Override
     	public boolean canCompute() {
-...
     	@Override
     	protected boolean _compute(boolean update)	{
     		this.loadParameters();
     		Log.info("Computing CAH...");
     		try {
     			RWorkspace rw = RWorkspace.getRWorkspaceInstance();

     package org.txm.progression.rcp.forms;
     import org.eclipse.swt.SWT;
     import org.eclipse.swt.custom.SashForm;
     import org.eclipse.swt.custom.ScrolledComposite;
     import org.eclipse.swt.layout.FillLayout;
     import org.eclipse.swt.layout.GridData;
     import org.eclipse.swt.layout.GridLayout;
     import org.eclipse.swt.widgets.Button;
     import org.eclipse.swt.widgets.Combo;
     import org.eclipse.swt.widgets.Composite;
     import org.eclipse.swt.widgets.Label;
     import org.eclipse.swt.widgets.Table;
     import org.eclipse.swt.widgets.Text;
     import org.txm.rcp.RCPMessages;
     public class ProgressionParametersComposite extends Composite {
     	SashForm sashForm;
     	private Table table;
     	private Text scaleTextEdit;
     	private Text regTextEdit;
     	Button btnSupprimer;
     	Button cumulBtn;
     	Button densiBtn;
     	Combo structCombo;
     	Combo propCombo;
     	private Button styleRadio;
     	private Button repeatRadio;
     	private Button NBRadio;
     	private Button btnNewButton;
     	/**
     	 * Creates the composite.
     	 * @param parent
     	 * @param style
     	 */
     	public ProgressionParametersComposite(Composite parent, int style) {
     		super(parent, style);
     		//parent.setLayout(new GridLayout(1, true));
     //		ExpandBar bar = new ExpandBar(parent, SWT.NONE);
     //		sashForm = new SashForm(parent, SWT.VERTICAL);
     //		sashForm.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true));
     		ScrolledComposite scrolledComposite_1 = new ScrolledComposite(parent, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
     		scrolledComposite_1.setExpandHorizontal(true);
     		scrolledComposite_1.setExpandVertical(true);
     //		Composite scrolledComposite_1 = new Composite(this, SWT.BORDER);
     		Composite composite_1 = new Composite(scrolledComposite_1, SWT.NONE);
     		composite_1.setLayout(new FillLayout(SWT.VERTICAL));
     		Composite composite = new Composite(composite_1, SWT.NONE);
     		composite.setLayout(new GridLayout(5, false));
     		Label label = new Label(composite, SWT.NONE);
     		GridData gd_label = new GridData(SWT.LEFT, SWT.CENTER, false, false, 1, 1);
     		gd_label.widthHint = 29;
     		label.setLayoutData(gd_label);
     		label.setText(RCPMessages.ProgressionForm_0);
     		cumulBtn = new Button(composite, SWT.RADIO);
     		cumulBtn.setText(RCPMessages.ProgressionForm_1);
     		cumulBtn.setSelection(true);

Laboratoire ICAR » Plateforme TXM

Révision 544