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

Révision 2386

     import java.awt.BorderLayout;
     import java.awt.Frame;
     import java.awt.GridLayout;
     import java.awt.Panel;
     import java.awt.event.KeyAdapter;
     import java.awt.event.KeyEvent;
     import java.awt.TextField;
     import javax.swing.JLabel;
     import javax.swing.JRootPane;
     import javax.swing.JTextField;
     import org.eclipse.swt.SWT;
     import org.eclipse.swt.awt.SWT_AWT;
     import org.eclipse.swt.layout.FillLayout;
     import org.eclipse.swt.widgets.Composite;
     import org.eclipse.swt.widgets.Display;
     import org.eclipse.swt.widgets.Event;
     import org.eclipse.swt.widgets.Listener;
     import org.eclipse.swt.widgets.Shell;
     import org.eclipse.swt.widgets.Text;
     /**
      * Focus bug in Linux minimal sample.
      * 1) if the AWT TextField has gained focus once, when clicking in the SWT Text widget, the key events are not transmitted
      * 2) the AWT Window never loses the focus
+     *
      */
     public class SWtSwingSnippet {
     	public static void main(String[] args) {
-...
     		final Shell shell = new Shell(display);
     		shell.setLayout(new FillLayout());
     		Composite composite = new Composite(shell, SWT.NO_BACKGROUND | SWT.EMBEDDED);
     		Composite composite = new Composite(shell, SWT.EMBEDDED);
     		try {
     			System.setProperty("sun.awt.noerasebackground","true");
     		} catch (NoSuchMethodError error) {}
     		/* Create and setting up frame */
     		Frame frame = SWT_AWT.new_Frame(composite);
     		Panel panel = new Panel(new BorderLayout()) {
     			public void update(java.awt.Graphics g) {
     				paint(g);
+    			}
     		};
     		Panel panel = new Panel(new BorderLayout());
     		frame.add(panel);
     		JRootPane root = new JRootPane();
     		panel.add(root);
     		java.awt.Container contentPane = root.getContentPane();
     		JLabel label1 = new JLabel("Text 1");
     		JTextField field1 = new JTextField(10);
     		panel.add(new TextField());
     		JLabel label2 = new JLabel("Text 2");
     		JTextField field2 = new JTextField(10);
     		contentPane.setLayout(new GridLayout(2,2));
     		contentPane.add(label1);
     		contentPane.add(field1);
     		contentPane.add(label2);
     		contentPane.add(field2);
     		Text text = new Text(shell, SWT.BORDER);
     		shell.setSize(200,70);
     		shell.open();
     		field1.addKeyListener(new KeyAdapter() {
     			public void keyPressed(KeyEvent e) {
     				System.out.println("key pressed in swing");
+    			}
     			public void keyReleased(KeyEvent e) {
     				System.out.println("key released in swing");			}
     			public void keyTyped(KeyEvent e) {
     				System.out.println("key typed in swing");
+    			}
     		});
     		display.addFilter(SWT.KeyDown,new Listener() {
     			public void handleEvent(Event event) {
     				System.out.println("key down in SWT");
+    			}
     		});
     		display.addFilter(SWT.KeyUp,new Listener() {
     			public void handleEvent(Event event) {
     				System.out.println("key up in SWT");
+    			}
     		});
     		display.addFilter(SWT.MouseMove,new Listener() {
     			public void handleEvent(Event event) {
     				System.out.println("mouse move in SWT");
+    			}
     		});
     		display.addFilter(SWT.MouseDown,new Listener() {
     			public void handleEvent(Event event) {
     				System.out.println("mouse down in SWT");
+    			}
     		});
     		display.addFilter(SWT.MouseUp,new Listener() {
     			public void handleEvent(Event event) {
     				System.out.println("mouse up in SWT");
+    			}
     		});
     		display.addFilter(SWT.MouseEnter,new Listener() {
     			public void handleEvent(Event event) {
     				System.out.println("mouse enter in SWT");
+    			}
     		});
     		while(!shell.isDisposed()) {
     			if (!display.readAndDispatch()) display.sleep();
     			if (!display.readAndDispatch()) {
     				display.sleep();
+    			}
+    		}
     		display.dispose();
+    	}

     		for(int i = 0; i < contributions.length; i++) {
     			// FIXME: to manage more than one input format, Store them in the class rather than in the extension schema?
     			// FIXME: SJ: to manage more than one input format, Store them in the class rather than in the extension schema?
     			String formatsStr = contributions[i].getAttribute("inputFormat").replace(" ", "").trim(); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     			String[] formats = formatsStr.split(","); //$NON-NLS-1$
-...
     	 * @param chartsEngine
     	 * @return the first components provider that manages the format of the specified charts engine
     	 */
     	public static SWTChartsComponentsProvider getComponentsProvider(ChartsEngine chartsEngine)	{
     	public static SWTChartsComponentsProvider getComponentsProvider(ChartsEngine chartsEngine) {
     		SWTChartsComponentsProvider chartsComponentsProvider = null;
     		for(int i = 0; i < SWTChartsComponentsProvider.chartsComponentsProviders.size(); i++) {
     			if(SWTChartsComponentsProvider.chartsComponentsProviders.get(i).canCreateView(chartsEngine))	{
     		for (int i = 0; i < SWTChartsComponentsProvider.chartsComponentsProviders.size(); i++) {
     			if (SWTChartsComponentsProvider.chartsComponentsProviders.get(i).canCreateView(chartsEngine)) {
     				chartsComponentsProvider = SWTChartsComponentsProvider.chartsComponentsProviders.get(i);
     				break;
+    			}
-...
     	 * @param type
     	 * @return the installed charts components provider according to its class type if it exists otherwise null
     	 */
     	public static SWTChartsComponentsProvider getComponentsProvider(Class type)	{
     	public static SWTChartsComponentsProvider getComponentsProvider(Class type) {
     		SWTChartsComponentsProvider provider = null;
     		for(int i = 0; i < SWTChartsComponentsProvider.chartsComponentsProviders.size(); i++) {
     			if(SWTChartsComponentsProvider.chartsComponentsProviders.get(i).getClass().equals(type))	{
     		for (int i = 0; i < SWTChartsComponentsProvider.chartsComponentsProviders.size(); i++) {
     			if (SWTChartsComponentsProvider.chartsComponentsProviders.get(i).getClass().equals(type)) {
     				provider = SWTChartsComponentsProvider.chartsComponentsProviders.get(i);
     				break;
+    			}
-...
     		return provider;
+    	}
     	/**
     	 * Checks if the components provider can create a composite to render a chart generated by the specified charts engine using its current output format.
+    	 *
     	 * @param chartsEngine
     	 * @return
     	 */
     	protected boolean canCreateView(ChartsEngine chartsEngine)	{
     	protected boolean canCreateView(ChartsEngine chartsEngine) {
     		return this.getEditorSupportedInputFormats().contains(chartsEngine.getOutputFormat());
+    	}
     	/**
     	 * Set the current charts engine.
+    	 *
     	 * @param chartsEngine the chartsEngine to set
     	 */
     	public void setChartsEngine(ChartsEngine chartsEngine) {
     		this.chartsEngine = chartsEngine;
+    	}
     	/**
     	 * Gets the charts engine.
+    	 *
     	 * @return the chartsEngine
     	 */
     	public ChartsEngine getChartsEngine() {

     /**
      * Chart result.
+     *
      * @author sjacquot
+     *
      */
     public abstract class ChartResult extends TXMResult {
     	/**
     	 * Linked charts engine.
     	 */
     	protected ChartsEngine chartsEngine;
     	/**
     	 * The chart object.
     	 */
     	protected Object chart;
     	/**
     	 * The chart dirty state.
     	 */
     	protected boolean chartDirty;
     	/**
     	 * If true, the view (zoom, pan, etc.) will be reset when the chart will be updated.
     	 */
     	protected boolean needsToResetView;
     	/**
     	 * If true, the items selection will cleared when the chart will be updated.
     	 */
     	protected boolean needsToClearItemsSelection;
     	/**
     	 * If true, the items selection will cleared when the chart will be updated.
     	 */
     	protected boolean needsToSquareOff;
     	/**
     	 * To show/hide domain grid lines.
     	 */
     	protected boolean domainGridLinesVisible;
     	/**
     	 * The chart type;
     	 */
     	@Parameter(key=ChartsEnginePreferences.CHART_TYPE, type=Parameter.RENDERING)
     	@Parameter(key = ChartsEnginePreferences.CHART_TYPE, type = Parameter.RENDERING)
     	protected String chartType;
     	/**
     	 * To show/hide title.
     	 */
     	@Parameter(key=ChartsEnginePreferences.SHOW_TITLE, type=Parameter.RENDERING)
     	@Parameter(key = ChartsEnginePreferences.SHOW_TITLE, type = Parameter.RENDERING)
     	protected boolean titleVisible;
     	/**
     	 * To show/hide legend.
     	 */
     	@Parameter(key=ChartsEnginePreferences.SHOW_LEGEND, type=Parameter.RENDERING)
     	@Parameter(key = ChartsEnginePreferences.SHOW_LEGEND, type = Parameter.RENDERING)
     	protected boolean legendVisible;
     	/**
     	 * To show/hide grid.
     	 */
     	@Parameter(key=ChartsEnginePreferences.SHOW_GRID, type=Parameter.RENDERING)
     	@Parameter(key = ChartsEnginePreferences.SHOW_GRID, type = Parameter.RENDERING)
     	protected boolean gridVisible;
     	/**
     	 * Rendering colors mode
     	 */
     	@Parameter(key=ChartsEnginePreferences.RENDERING_COLORS_MODE, type=Parameter.RENDERING)
     	@Parameter(key = ChartsEnginePreferences.RENDERING_COLORS_MODE, type = Parameter.RENDERING)
     	protected int renderingColorsMode;
     	/**
     	 * Font.
     	 */
     	@Parameter(key=ChartsEnginePreferences.FONT, type=Parameter.RENDERING)
     	@Parameter(key = ChartsEnginePreferences.FONT, type = Parameter.RENDERING)
     	protected String font;
     	/**
     	 * Multiple lines styles/strokes.
     	 */
     	@Parameter(key=ChartsEnginePreferences.MULTIPLE_LINE_STROKES, type=Parameter.RENDERING)
     	@Parameter(key = ChartsEnginePreferences.MULTIPLE_LINE_STROKES, type = Parameter.RENDERING)
     	protected boolean multipleLineStrokes;
     	/**
     	 * Creates a new ChartResult child of the specified parent.
+    	 *
     	 * @param parent
     	 */
     	public ChartResult(TXMResult parent) {
     		this(null, parent);
+    	}
     	/**
     	 * Creates a new ChartResult with no parent.
     	 * If a local node exist with the parent_uuid, the parent will be retrieved and this result will be added to it.
     	 * If a local node exist with the parent_uuid, the parent will be retrieved and this result will be added to it.
+    	 *
     	 * @param parametersNodePath
     	 */
     	public ChartResult(String parametersNodePath) {
     		this(parametersNodePath, null);
+    	}
     	/**
     	 * Creates a new ChartResult child of the specified parent.
+    	 *
     	 * @param uuid
     	 * @param parent
     	 */
-...
     		this.needsToSquareOff = false;
     		this.domainGridLinesVisible = true;
+    	}
     	@Override
     	protected boolean autoLoadParametersFromAnnotations() throws Exception {
     		return (super.autoLoadParametersFromAnnotations()
     				&& super.autoLoadParametersFromAnnotations(Parameter.RENDERING));
+    	}
     	@Override
     	public void setDirty() {
     		super.setDirty();
     		//this.chart = null;
     		// this.chart = null; // FIXME: SJ: became useless?
     		this.setChartDirty();
+    	}
     	/**
+    	 *
     	 */
     	public void setChartDirty() {
     		this.chartDirty = true;
+    	}
     	@Override
     	public boolean compute(IProgressMonitor monitor) {
     		return compute(monitor, true);
+    	}
     	/**
     	 * This method is dedicated to be implemented by the inherited chart result classes to define the computing steps.
     	 * This method is dedicated to be implemented by the inherited chart result classes to define the computing steps.
+    	 *
     	 * @return true if the result was computed
+    	 *
     	 * @throws Exception
-...
     	@Override
     	protected final boolean _compute()	{
     	protected final boolean _compute() {
     		boolean computingState = true;
     		try {
     			Log.finest("*** ChartResult._compute(): " + this.getClass().getSimpleName() + ": starting computing process...");
     			// Computes the result only if at least one computing parameter has changed
     			//if(this.hasParameterChanged())	{
     				computingState = this.__compute();
     			//}
     				if (computingState) {
     					computingState = this.renderChart();
+    				}
     			// FIXME: SJ: Computes the result only if at least one computing parameter has changed
     			// if(this.hasParameterChanged()) {
     			computingState = this.__compute();
     			// }
     			if (computingState) {
     				computingState = this.renderChart();
+    			}
+    		}
     		catch (Exception e) {
     			e.printStackTrace();
-...
     		return computingState;
+    	}
     	/**
     	 * Renders the chart using the right chart creator.
     	 * The chart is created if needed then it is updated.
-...
     	 * @throws Exception
     	 */
     	protected boolean renderChart() throws Exception {
     		this.subTask("Rendering chart for result " + this.getClass() + " and chart type " + this.getChartType() + ".");
     		Log.finest("*** ChartResult.renderChart(): rendering chart for result " + this.getClass() + " and chart type " + this.getChartType() + "..."); //$NON-NLS-1$
     		// update the chart dirty state from history if a parameter has changed since last computing
     		this.updateChartDirtyFromHistory();
-...
     			Log.finest("--- ChartResult.renderChart(): chart rendering parameters have not changed since last rendering, rendering skipped."); //$NON-NLS-1$
     			return true;
+    		}
     		ChartCreator chartCreator = this.getChartCreator();
     		// try to find a chart creator in other charts engines
     		if(chartCreator == null)	{
     		if (chartCreator == null) {
     			for (int i = 0; i < ChartsEngine.getChartsEngines().size(); i++) {
     				ChartsEngine chartsEngine = ChartsEngine.getChartsEngines().get(i);
     				if(chartsEngine == this.chartsEngine)	{
     				ChartsEngine chartsEngine = ChartsEngine.getChartsEngines().get(i);
     				if (chartsEngine == this.chartsEngine) {
     					continue;
+    				}
     				chartCreator = chartsEngine.getChartCreator(this);
     				if(chartCreator != null)	{
     				if (chartCreator != null) {
     					Log.finest("ChartResult.renderChart(): another suitable chart creator has been found in charts engine: " + chartsEngine + "."); //$NON-NLS-1$
     					this.chartsEngine = chartsEngine;
     					break;
+    				}
+    			}
+    		}
     		if(chartCreator != null)	{
     		if (chartCreator != null) {
     			// FIXME: fix #1
     			// FIXME: SJ: without this, this.hasParameterChanged(ChartsEnginePreferences.CHART_TYPE) returns true for results that added their computing parameters in the parameter history.
     			// Since the stack is shared by computing and rendering parameters, this.hasParameterChanged(ChartsEnginePreferences.CHART_TYPE) returns true because the parameter doesn't exist in the last stack entry filled only with the computing parameter
     			// Since the stack is shared by computing and rendering parameters, this.hasParameterChanged(ChartsEnginePreferences.CHART_TYPE) returns true because the parameter doesn't exist in the
     			// last stack entry filled only with the computing parameter
     			// may need to fix this in another way:
     			// Solution 1: store two stacks, one for computing parameters and another for rendering parameters
     			// Solution 2: stop to dissociate rendering parameters and computing parameters. Maybe the best way but need to check if this dissociation is very useless
     			// clear the last computing parameters
     //			if(this.parametersHistory.size() > 2
     //
     //					//|| this.getLastParametersFromHistory().isEmpty()
     //					)	{
     //				this.clearLastComputingParameters();
     //			}
     			// if(this.parametersHistory.size() > 2
     			//
     			// //|| this.getLastParametersFromHistory().isEmpty()
     			// ) {
     			// this.clearLastComputingParameters();
     			// }
     			// Creating, if needed.
     			// The change of the chart type parameter can occur if:
     			// - the chart has never been created
     			// - the chart type has been changed, e.g. to dynamically change the type of chart or the current charts engine
     			if (this.chart == null ||
     					(this.getLastParametersFromHistory().get(ChartsEnginePreferences.CHART_TYPE) != null &&
     					this.hasParameterChanged(ChartsEnginePreferences.CHART_TYPE))
     					//)
     					) {
     			if (this.chart == null ||
     					(this.getLastParametersFromHistory().get(ChartsEnginePreferences.CHART_TYPE) != null &&
     							this.hasParameterChanged(ChartsEnginePreferences.CHART_TYPE))
     			// )
     			) {
     				Log.finest("+++ ChartResult.renderChart(): creating chart..."); //$NON-NLS-1$
     				this.chart = chartCreator.createChart(this);
+    			}
     			// Updating
     			Log.finest("ChartResult.renderChart(): updating chart..."); //$NON-NLS-1$
     			// the update must be done here (BEFORE the call of this.updateLastRenderingParameters()) rather than in the SWTChartComponentsProvider => the problem is that for File based Engine, the file may be created twice, need to check this
     			// also before the call of this.updateLastParameters() to be able to check if a computing parameter has changed in the chart creators
     			//FIXME: SJ: this call doesn't work well with File based charts engines, the file is created one time in createChartFile() and a second time in updateChart()
     			// the update must be done here (BEFORE the call of this.updateLastRenderingParameters()) rather than in the SWTChartComponentsProvider => the problem is that for File based Engine, the
     			// file may be created twice, need to check this
     			// also before the call of this.updateLastParameters() to be able to check if a computing parameter has changed in the chart creators
     			// FIXME: SJ: this call doesn't work well with File based charts engines, the file is created one time in createChartFile() and a second time in updateChart()
     			chartCreator.updateChart(this);
     			// FIXME: needed by the above fix #1
     			// reupdate the last computing parameters
     			//this.updateLastParameters();
     			//this.updateLastRenderingParameters();
     			// this.updateLastParameters();
     			// this.updateLastRenderingParameters();
     			this.needsToClearItemsSelection = false;
     			this.needsToResetView = false;
     			this.chartDirty = false;
     			// Debug
     			Log.finest("ChartResult.renderChart(): chart rendering done."); //$NON-NLS-1$
     			return true;
+    		}
     		else	{
     		else {
     			Log.severe("ChartResult.renderChart(): can not find any suitable chart creator for result: " + this.getClass() + "."); //$NON-NLS-1$
     			return false;
+    		}
+    	}
     	@Override
     	public String dumpParameters() {
     		return super.dumpParameters() + "\n" + this.dumpParameters(Parameter.RENDERING); //$NON-NLS-1$
+    	}
     	/**
     	 * Clears the parameters used for last rendering.
     	 * Dedicated to force a chart recreation, eg. for cloning the chart result or for dynamically changing the chart type .
+    	 *
     	 * @throws Exception
     	 */
     	public void clearLastRenderingParameters() {
     		this.clearLastParameters(Parameter.RENDERING);
+    	}
     	/**
     	 * Checks if at least one rendering parameter value has changed since last computing.
+    	 *
     	 * @return
     	 * @throws Exception
     	 */
-...
     	@Override
     	public void updateDirtyFromHistory() throws Exception {
     		this.dirty = super.hasParameterChanged();
     		if(!this.dirty)	{
     		if (!this.dirty) {
     			this.dirty = this.hasRenderingParameterChanged();
+    		}
+    	}
-...
     	/**
     	 * Sets the chart dirty state to true if a rendering parameter has changed since last computing.
+    	 *
     	 * @return
     	 * @throws Exception
     	 */
     	public void updateChartDirtyFromHistory() throws Exception {
     		if(this.hasRenderingParameterChanged())	{
     		if (this.hasRenderingParameterChanged()) {
     			this.chartDirty = true;
+    		}
+    	}
     	@Override
     	public ChartResult clone() {
     		ChartResult clone = null;
     		clone = (ChartResult) super.clone();
     		clone.chart = null;
     		// FIXME: SJ: would be nice to clone the chart if possible instead of clearing the last rendering parameters?
     		//clone.chart = this.chart.clone();
     		// clone.chart = this.chart.clone();
     		clone.clearLastRenderingParameters(); // to force recreation of the chart at next computing // FIXME: SJ: need to see if it's necessary, the chartDirty state may be sufficient
     		clone.chartDirty = true;
     		clone.hasBeenComputedOnce = false;
     		return clone;
+    	}
     	/**
     	 * @return the chart
     	 */
     	public Object getChart() {
     		return chart;
+    	}
     	/**
     	 * @return the chartType
     	 */
     	public String getChartType() {
     		return chartType;
+    	}
     	/**
     	 * Gets a chart creator for this chart result according to its current type and current charts engine.
     	 * Gets a chart creator for this chart result according to its current type and current charts engine.
+    	 *
     	 * @return a suitable chart creator if exists, otherwise null
     	 */
     	public ChartCreator getChartCreator()	{
     	public ChartCreator getChartCreator() {
     		return this.chartsEngine.getChartCreator(this);
+    	}
     	/**
     	 * @param chartType the chartType to set
     	 */
-...
     		// FIXME: SJ: need to validate this
     		this.getLastParametersFromHistory().put(ChartsEnginePreferences.CHART_TYPE, "__undef___"); //$NON-NLS-1$
     		//this.getLastParametersFromHistory().put(ChartsEnginePreferences.CHART_TYPE, "[Default]");
     		// this.getLastParametersFromHistory().put(ChartsEnginePreferences.CHART_TYPE, "[Default]");
     		// clear all last parameters to force a full recomputing
     		//this.clearLastRenderingParameters();
     		//		this.clearLastRenderingParameters();
     		// this.clearLastRenderingParameters();
     		// this.clearLastRenderingParameters();
+    	}
     	/**
     	 * Sets the chart type as default.
     	 */
     	public void setDefaultChartType()	{
     	public void setDefaultChartType() {
     		this.setChartType(ChartsEnginePreferences.DEFAULT_CHART_TYPE);
+    	}
     	/**
     	 * Checks if the current chart type is the default one.
+    	 *
     	 * @return
     	 */
     	public boolean isDefaultChartType()	{
     	public boolean isDefaultChartType() {
     		return ChartsEnginePreferences.DEFAULT_CHART_TYPE.equals(this.chartType);
+    	}
     	/**
     	 * @return the chartDirty
     	 */
     	public boolean isChartDirty() {
     		return chartDirty;
+    	}
     	/**
     	 * @return the needsToResetView
     	 */
     	public boolean needsToResetView() {
     		return needsToResetView;
+    	}
     	/**
     	 * @param needsToResetView the needsToResetView to set
     	 */
     	public void setNeedsToResetView(boolean needsToResetView) {
     		this.needsToResetView = needsToResetView;
+    	}
     	/**
     	 * @return the needsClearItemsSelection
     	 */
     	public boolean needsToClearItemsSelection() {
     		return needsToClearItemsSelection;
+    	}
     	/**
     	 * @param needsToClearItemsSelection the needsClearItemsSelection to set
     	 */
     	public void setNeedsToClearItemsSelection(boolean needsToClearItemsSelection) {
     		this.needsToClearItemsSelection = needsToClearItemsSelection;
+    	}
     	/**
     	 * Gets the square off constraint state.
+    	 *
     	 * @return the square off constraint state
     	 */
     	public boolean needsToSquareOff() {
     		return needsToSquareOff;
+    	}
     	/**
     	 * Sets the square off constraint state.
+    	 *
     	 * @param needsToSquareOff the square off constraint state to set
     	 */
     	public void setNeedsToSquareOff(boolean needsToSquareOff) {
     		this.needsToSquareOff = needsToSquareOff;
+    	}
     	/**
     	 * Gets the title visibility state.
+    	 *
     	 * @return the titleVisible
     	 */
     	public boolean isTitleVisible() {
     		return titleVisible;
+    	}
     	/**
     	 * Sets the title visibility state.
+    	 *
     	 * @param titleVisible the titleVisible to set
     	 */
     	public void setTitleVisible(boolean titleVisible) {
     		this.titleVisible = titleVisible;
+    	}
     	/**
     	 * Gets the legend visibility state.
+    	 *
     	 * @return the legendVisible
     	 */
     	public boolean isLegendVisible() {
     		return legendVisible;
+    	}
     	/**
     	 * Sets the legend visibility state.
+    	 *
     	 * @param legendVisible the legendVisible to set
     	 */
     	public void setLegendVisible(boolean legendVisible) {
     		this.legendVisible = legendVisible;
+    	}
     	/**
     	 * Gets the grid visibility state.
+    	 *
     	 * @return the gridVisible
     	 */
     	public boolean isGridVisible() {
     		return gridVisible;
+    	}
     	/**
     	 * Gets the domain grid lines visibility state.
+    	 *
     	 * @return the domainGridLinesVisible
     	 */
     	public boolean isDomainGridLinesVisible() {
     		return domainGridLinesVisible;
+    	}
     	/**
     	 * Sets the visiiblity visibility state.
+    	 *
     	 * @param gridVisible the gridVisible to set
     	 */
     	public void setGridVisible(boolean gridVisible) {
     		this.gridVisible = gridVisible;
+    	}
     	/**
     	 * Gets the rendering color mode as integer.
+    	 *
     	 * @return the renderingColorsMode
     	 */
     	public int getRenderingColorsMode() {
     		return renderingColorsMode;
+    	}
     	/**
     	 * Gets the rendering color mode.
+    	 *
     	 * @param renderingColorsMode the renderingColorsMode to set
     	 */
     	public void setRenderingColorsMode(int renderingColorsMode) {
     		this.renderingColorsMode = renderingColorsMode;
+    	}
     	/**
     	 * Gets the font.
+    	 *
     	 * @return the font
     	 */
     	public String getFont() {
     		return font;
+    	}
     	/**
     	 * Sets the font.
+    	 *
     	 * @param font the font to set
     	 */
     	public void setFont(String font) {
     		this.font = font;
+    	}
     	/**
     	 * Gets the multiple line strokes state.
+    	 *
     	 * @return the multipleLineStrokes
     	 */
     	public boolean isMultipleLineStrokes() {
     		return multipleLineStrokes;
+    	}
     	/**
     	 * Sets the multiple line strokes state.
+    	 *
     	 * @param multipleStrokes the multiple line strokes state to set
     	 */
     	public void setMultipleLineStrokes(boolean multipleStrokes) {
     		this.multipleLineStrokes = multipleStrokes;
+    	}
     	/**
     	 * Gets the current charts engine used for the rendering.
+    	 *
     	 * @return the chartsEngine
     	 */
     	public ChartsEngine getChartsEngine() {
     		return chartsEngine;
+    	}
     	/**
     	 * Sets the charts engine to use for the rendering.
+    	 *
     	 * @param chartsEngine the chartsEngine to set
     	 */
     	public void setChartsEngine(ChartsEngine chartsEngine) {
     		this.chartsEngine = chartsEngine;
+    	}
     	/**
     	 * Sets the chart object.
+    	 *
     	 * @param chart the chart to set
     	 */
     	public void setChart(Object chart) {
     		this.chart = chart;
+    	}
+    }

     	/**
     	 * Constants for output formats and file extensions.
     	 */
     	public final static String OUTPUT_FORMAT_NONE = "NONE", OUTPUT_FORMAT_JPEG = "jpeg", OUTPUT_FORMAT_PDF = "pdf", OUTPUT_FORMAT_PNG = "png", OUTPUT_FORMAT_PS = "ps", OUTPUT_FORMAT_SVG = "svg", OUTPUT_FORMAT_BMP = "bmp", OUTPUT_FORMAT_GIF = "gif";
     	public final static String OUTPUT_FORMAT_NONE = "NONE", OUTPUT_FORMAT_JPEG = "jpeg", OUTPUT_FORMAT_PDF = "pdf", OUTPUT_FORMAT_PNG = "png", OUTPUT_FORMAT_PS = "ps", OUTPUT_FORMAT_SVG = "svg",
     			OUTPUT_FORMAT_BMP = "bmp", OUTPUT_FORMAT_GIF = "gif";
     	/**
     	 * Constants for the colors rendering modes.
     	 */
     	public final static int RENDERING_COLORS_MODE = 0, RENDERING_GRAYSCALE_MODE = 1, RENDERING_BLACK_AND_WHITE_MODE = 2, RENDERING_MONOCHROME_MODE = 3;
     	/**
     	 * The engine description.
     	 */
     	protected String description;
     	/**
     	 * The current output format.
     	 */
-...
     	 * Chart creators extension contributions.
     	 */
     	protected HashMap<Class, HashMap<String, ChartCreator>> chartCreators;
     	/**
     	 * Installed charts engines.
     	 * TODO remove this static member and use the ChartsEnginesManager
     	 * TODO remove this static member and use the ChartsEnginesManager
     	 */
     	protected static ArrayList<ChartsEngine> chartsEngines;
-...
     	/**
     	 * UI related, this preference can be used to tell if the chart must be updated directly after editing a widget value or only after pressed a "Compute" button.
     	 */
     	//FIXME: SJ: this preference is not used at this time, see if it's useless or not.
     	protected boolean directComputing;
     	// FIXME: SJ: this preference is not used at this time, see if it's useless or not.
     	protected boolean directComputing;
     	// add the preference node qualifier to the preferences so the command use some preferences if they do not define themselves
     	static	{
     	static {
     		TXMPreferences.alternativeNodesQualifiers.add(ChartsEnginePreferences.getInstance().getPreferencesNodeQualifier());
+    	}
     	/**
     	 * Creates a charts engine with the specified name, description and output format.
+    	 *
     	 * @param name
     	 * @param description
     	 * @param outputFormat
     	 */
     	protected ChartsEngine(String description, String outputFormat) {
     		this.chartCreators = new HashMap<Class, HashMap<String,ChartCreator>>();
     		this.chartCreators = new HashMap<Class, HashMap<String, ChartCreator>>();
     		this.description = description;
     		this.outputFormat = outputFormat;
     		this.theme = new Theme();
     		//FIXME: SJ: this preference is not used at this time, see if it's useless or not.
     		// FIXME: SJ: this preference is not used at this time, see if it's useless or not.
     		this.directComputing = true;
+    	}
     	/**
     	 * Gets a chart creator for the specified result and chart type.
+    	 *
-...
     	 * @param showLogWarning
     	 * @return A chart creator if it exists otherwise <code>null</code>
     	 */
     	public ChartCreator getChartCreator(ChartResult result, String chartType, boolean showLogWarning)	{
     	public ChartCreator getChartCreator(ChartResult result, String chartType, boolean showLogWarning) {
     		ChartCreator chartCreator = null;
     		HashMap<String, ChartCreator> map = this.chartCreators.get(result.getClass());
     		if(map != null)	{
     		if (map != null) {
     			chartCreator = map.get(chartType);
+    		}
     		if(chartCreator == null && showLogWarning)	{
     		if (chartCreator == null && showLogWarning) {
     			Log.fine(this.getName() + ": No chart creator can be found for result: " + result.getClass() + " and chart type: " + chartType + "."); //$NON-NLS-1$
+    		}
     		return chartCreator;
-...
     	/**
     	 * Gets a chart creator for the specified result and default chart type.
+    	 *
     	 * @param result
     	 * @param showLogWarning
     	 * @return
     	 */
     	public ChartCreator getChartCreator(ChartResult result, boolean showLogWarning)	{
     	public ChartCreator getChartCreator(ChartResult result, boolean showLogWarning) {
     		return this.getChartCreator(result, result.getChartType(), showLogWarning);
+    	}
     	/**
     	 * Gets a chart creator for the specified result and chart type.
+    	 *
     	 * @param result
     	 * @param chartType
     	 * @return
     	 */
     	public ChartCreator getChartCreator(ChartResult result, String chartType)	{
     	public ChartCreator getChartCreator(ChartResult result, String chartType) {
     		return this.getChartCreator(result, chartType, true);
+    	}
     	/**
     	 * Gets a chart creator for the specified result and default chart type.
+    	 *
     	 * @param result
     	 * @return
     	 */
     	public ChartCreator getChartCreator(ChartResult result)	{
     	public ChartCreator getChartCreator(ChartResult result) {
     		return this.getChartCreator(result, result.getChartType());
+    	}
     	/**
     	 * Gets a list of all installed chart creators for the specified result.
+    	 *
     	 * @param result
     	 * @return
     	 */
     	public ArrayList<ChartCreator> getChartCreators(ChartResult result)	{
     	public ArrayList<ChartCreator> getChartCreators(ChartResult result) {
     		ArrayList<ChartCreator> chartCreators = new ArrayList<ChartCreator>();
     		HashMap<String, ChartCreator> map = this.chartCreators.get(result.getClass());
     		if(map != null)	{
     		if (map != null) {
     			chartCreators.addAll(map.values());
+    		}
     		return chartCreators;
+    	}
     	/**
     	 * Checks if the charts engine can create a chart according to the specified result and chart type.
+    	 *
-...
     	 * @param chartType
     	 * @return <code>True</code> if a chart creator can be found, otherwise <code>false</code>
     	 */
     	public boolean canCreateChart(ChartResult result, String chartType)	{
     	public boolean canCreateChart(ChartResult result, String chartType) {
     		return this.getChartCreator(result, chartType, false) != null;
+    	}
     	/**
     	 * Checks if the charts engine can create a chart according to the specified result data type.
+    	 *
     	 * @param resultDataType
     	 * @return <code>True</code> if a chart creator can be found, otherwise <code>false</code>
     	 */
     	public boolean canCreateChart(ChartResult result)	{
     	public boolean canCreateChart(ChartResult result) {
     		return this.getChartCreator(result, false) != null;
+    	}
     	/**
     	 * Adds a chart creator for the specified result data type and chart type.
+    	 *
     	 * @param resultDataType
     	 * @param chartCreator
     	 * @param chartType
     	 */
     	public void addChartCreator(Class resultDataType, ChartCreator chartCreator)	{
     	public void addChartCreator(Class resultDataType, ChartCreator chartCreator) {
     		String chartType = chartCreator.getChartType();
     		if(chartType == null)	{
     		if (chartType == null) {
     			chartType = ChartsEnginePreferences.DEFAULT_CHART_TYPE;
+    		}
     		if(!this.chartCreators.containsKey(resultDataType))	{
     		if (!this.chartCreators.containsKey(resultDataType)) {
     			HashMap<String, ChartCreator> m = new HashMap<String, ChartCreator>();
     			m.put(chartType, chartCreator);
     			this.chartCreators.put(resultDataType, m);
+    		}
     		else	{
     		else {
     			this.chartCreators.get(resultDataType).put(chartType, chartCreator);
+    		}
     		chartCreator.setChartsEngine(this);
     		chartCreator.setChartsEngine(this);
     		String log = this.getName() + ": Chart creator " + chartCreator.getClass().getSimpleName() + " added for result data type: " + resultDataType; //$NON-NLS-1$ //$NON-NLS-2$
     		if(chartType != null)	{
     		if (chartType != null) {
     			log += " (chart type: " + chartType + ")"; //$NON-NLS-1$ //$NON-NLS-2$
+    		}
     		log +="."; //$NON-NLS-1$
     		log += "."; //$NON-NLS-1$
     		Log.finest(log);
+    	}
     	/**
     	 * Gets the current charts engine.
     	 * Convenience method to return the current chart engine of the charts engines manager.
+    	 *
     	 * @return the current charts engine
     	 */
     	public static ChartsEngine getCurrent()	{
     	public static ChartsEngine getCurrent() {
     		return ChartsEnginesManager.getInstance().getCurrentEngine();
+    	}
     // FIXME: SJ: became useless?
     //	/**
     //	 * Gets an installed charts engine according to its class type.
     //	 * @param type
     //	 * @return the installed charts engine according to its class type if it exists otherwise null
     //	 */
     //	@Deprecated
     //	public static ChartsEngine getChartsEngine(Class type)	{
     //		ChartsEngine chartsEngine = null;
     //		for(int i = 0; i < ChartsEngine.chartsEngines.size(); i++) {
     //			if(ChartsEngine.chartsEngines.get(i).getClass().equals(type))	{
     //				chartsEngine = ChartsEngine.chartsEngines.get(i);
     //				break;
     //			}
     //		}
     //		return chartsEngine;
     //	}
     //	/**
     //	 * Gets an installed charts engine according to its name.
     //	 * @param type
     //	 * @return the installed charts engine according to its name if it exists otherwise null
     //	 */
     //	@Deprecated
     //	public static ChartsEngine getChartsEngineByName(String name)	{
     //		ChartsEngine chartsEngine = null;
     //		for(int i = 0; i < ChartsEngine.chartsEngines.size(); i++) {
     //			if(chartsEngines.get(i).getName().equals(name))	{
     //				chartsEngine = ChartsEngine.chartsEngines.get(i);
     //				break;
     //			}
     //		}
     //		return chartsEngine;
     //	}
     //
     //	/**
     //	 * Gets the first charts engine that can render the specified result.
     //	 * @param result
     //	 * @return
     //	 */
     //	@Deprecated
     //	public static ChartsEngine getChartsEngine(ChartResult result)	{
     //		ChartsEngine chartsEngine = null;
     //		for (int i = 0; i < ChartsEngine.chartsEngines.size(); i++) {
     //			if(ChartsEngine.chartsEngines.get(i).canCreateChart(result))	{
     //				chartsEngine = ChartsEngine.chartsEngines.get(i);
     //				break;
     //			}
     //		}
     //		return chartsEngine;
     //	}
     	// FIXME: SJ: became useless?
     	// /**
     	// * Gets an installed charts engine according to its class type.
     	// * @param type
     	// * @return the installed charts engine according to its class type if it exists otherwise null
     	// */
     	// @Deprecated
     	// public static ChartsEngine getChartsEngine(Class type) {
     	// ChartsEngine chartsEngine = null;
     	// for(int i = 0; i < ChartsEngine.chartsEngines.size(); i++) {
     	// if(ChartsEngine.chartsEngines.get(i).getClass().equals(type)) {
     	// chartsEngine = ChartsEngine.chartsEngines.get(i);
     	// break;
     	// }
     	// }
     	// return chartsEngine;
     	// }
     	// /**
     	// * Gets an installed charts engine according to its name.
     	// * @param type
     	// * @return the installed charts engine according to its name if it exists otherwise null
     	// */
     	// @Deprecated
     	// public static ChartsEngine getChartsEngineByName(String name) {
     	// ChartsEngine chartsEngine = null;
     	// for(int i = 0; i < ChartsEngine.chartsEngines.size(); i++) {
     	// if(chartsEngines.get(i).getName().equals(name)) {
     	// chartsEngine = ChartsEngine.chartsEngines.get(i);
     	// break;
     	// }
     	// }
     	// return chartsEngine;
     	// }
     	//
     	// /**
     	// * Gets the first charts engine that can render the specified result.
     	// * @param result
     	// * @return
     	// */
     	// @Deprecated
     	// public static ChartsEngine getChartsEngine(ChartResult result) {
     	// ChartsEngine chartsEngine = null;
     	// for (int i = 0; i < ChartsEngine.chartsEngines.size(); i++) {
     	// if(ChartsEngine.chartsEngines.get(i).canCreateChart(result)) {
     	// chartsEngine = ChartsEngine.chartsEngines.get(i);
     	// break;
     	// }
     	// }
     	// return chartsEngine;
     	// }
     	/**
     	 * Returns the installed charts engine contributions.
+    	 *
     	 * @return
     	 */
     	@Deprecated
     	public static ArrayList<ChartsEngine> getChartsEngines()	{
     	public static ArrayList<ChartsEngine> getChartsEngines() {
     		return ChartsEngine.chartsEngines;
+    	}
     	@Override
     	public boolean initialize() throws Exception {
     		this.registerChartCreatorExtensions();
     		return true;
+    	}
     	/**
     	 * Populates the chart creators from loaded extensions according to the specified chars engine name.
+    	 *
     	 * @param chartsEngineName
     	 */
     	protected void registerChartCreatorExtensions(Class chartsEngineClass)	{
     	protected void registerChartCreatorExtensions(Class chartsEngineClass) {
     		IConfigurationElement[] contributions = Platform.getExtensionRegistry().getConfigurationElementsFor(ChartCreator.extensionPointId);
     		for(int i = 0; i < contributions.length; i++) {
     		for (int i = 0; i < contributions.length; i++) {
     			try {
     				ChartCreator chartCreator = (ChartCreator) contributions[i].createExecutableExtension("class"); //$NON-NLS-1$
     				if(chartsEngineClass.equals(chartCreator.getChartsEngineClass()))	{
     				if (chartsEngineClass.equals(chartCreator.getChartsEngineClass())) {
     					chartCreator.setFileNamePrefix(contributions[i].getAttribute("fileNamePrefix")); //$NON-NLS-1$
     					chartCreator.setChartType(contributions[i].getAttribute("chartType")); //$NON-NLS-1$
     					this.addChartCreator(chartCreator.getResultDataClass(), chartCreator); //$NON-NLS-1$
     					this.addChartCreator(chartCreator.getResultDataClass(), chartCreator); // $NON-NLS-1$
+    				}
+    			}
     			catch(CoreException e) {
     			catch (CoreException e) {
     				// TODO Auto-generated catch block
     				e.printStackTrace();
+    			}
+    			}
+    		}
+    	}
     	/**
     	 * Populates the chart creators from loaded extensions.
     	 */
     	public void registerChartCreatorExtensions()	{
     	public void registerChartCreatorExtensions() {
     		this.registerChartCreatorExtensions(this.getClass());
+    	}
     	/**
     	 * Creates a font from the specified encoded String in JFace format (eg.: "1|Lucida Sans Unicode|12.0|0|WINDOWS|1|-16|0|0|0|400|0|0|0|0|3|2|1|34|Lucida Sans Unicode;")
+    	 *
     	 * @param encodedStr
     	 * @return the decoded font
     	 */
     	public static Font createFont(String encodedStr)	{
     	public static Font createFont(String encodedStr) {
     		String[] data = encodedStr.split("\\|");
     		Font font = new Font(data[1], Integer.valueOf(data[3]), Integer.parseInt(data[2].split("\\.")[0]));
     		return font;
-...
     	/**
     	 * Creates a font from the current global charts engine font preference.
+    	 *
     	 * @return
     	 */
     	public static Font createFont()	{
     	public static Font createFont() {
     		return createFont(ChartsEnginePreferences.getInstance().getString(ChartsEnginePreferences.FONT));
+    	}
-...
+    	 *
     	 * @return
     	 */
     	public File createTmpFile(String prefix)	{
     	public File createTmpFile(String prefix) {
     		File file = null;
     		try {
     			File resultsDir = new File(Toolbox.getTxmHomePath(), "results"); //$NON-NLS-1$
     			resultsDir.mkdirs();
     			// right padding to 3 characters long
     			if(prefix.length() < 3)	{
     				prefix =  String.format("%1$-3s", prefix).replace(' ', '_'); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     			if (prefix.length() < 3) {
     				prefix = String.format("%1$-3s", prefix).replace(' ', '_'); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+    			}
     			file = File.createTempFile(prefix, "." + this.outputFormat, resultsDir);
-...
     			Log.severe(NLS.bind(ChartsEngineCoreMessages.error_cantCreateTmpChartFileP0, e));
     			Log.printStackTrace(e);
+    		}
     		// TODO : old code, useful ? and/or return null instead of the file if canWrite() return false ?
     		if(!file.canWrite()) {
     		if (!file.canWrite()) {
     			Log.severe(NLS.bind(ChartsEngineCoreMessages.error_cantWriteInFileP0, file));
+    		}
     		return file;
+    	}
     	/**
     	 * Creates a file form the specified chart object.
+    	 *
     	 * @param chart
     	 * @param file
     	 * @return
-...
     	/**
     	 * Creates a chart according to the specified result and output format and writes it in the specified file.
+    	 *
     	 * @param result
     	 * @param file
     	 * @param outputFormat
     	 * @return
     	 */
     	//FIXME: check that modification works well
     	public File createChartFile(ChartResult result, File file, String outputFormat)	{
     		// FIXME : bad ? Switch the current charts engine output format, export the chart, and then roll back the output format
     	public File createChartFile(ChartResult result, File file, String outputFormat) {
     		// FIXME : SJ: bad ? Switch the current charts engine output format, export the chart, and then roll back the output format
     		String oldOutputFormat = this.outputFormat;
     		this.setOutputFormat(outputFormat);
     		file = this.createChartFile(result.getChart(), file);
     		//this.setOutputFormat(oldOutputFormat);
     		this.outputFormat = oldOutputFormat;
     		return file;
+    	}

... 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 2386