Laboratoire ICAR » Plateforme TXM

		// FIXME : needed for automatic refresh after dynamically modifying the SVG DOM

			// FIXME: Debug

			// FIXME: Debug

				// FIXME: Debug

				// FIXME: Debug

			// FIXME: Children cascade computing

				// FIXME: Debug

			// FIXME: Debug

		// not implemented in TxmObjects

		// FIXME: need to do something?

Require-Bundle: org.txm.rcp;bundle-version="0.7.8";visibility:=reexport

	 * Linked editors.

	 */

	//FIXME: should be at TXMEditor level

	protected ArrayList<EditorPart> linkedEditors = null;

	/**

	 * Links the specified editor to this editor.

	 * @param editor

	 */

	//FIXME: should be at TXMEditor level

	public void addLinkedEditor(final EditorPart editor)	{

		if (this.linkedEditors == null)	{

			this.linkedEditors = new ArrayList<EditorPart>();

		}

		if (!this.linkedEditors.contains(editor))	{

			this.linkedEditors.add(editor);

			// FIXME: debug

			//System.err.println(this.getClass().getSimpleName() + ": A linked editor of type \"" + editor.getClass().getSimpleName() + "\" has been added to this one. Linked editors count: " + this.linkedEditors.size() + ".");

			// FIXME: temporary solution to break the link with chart editor from another TXM result editor when its closed

			// a better solution would be to redefine the onclose event in a root class of all TXM editors

			editor.getSite().getPage().addPartListener(new IPartListener() {

	            @Override

	            public void partOpened(IWorkbenchPart part) {

	                // TODO Auto-generated method stub

	            }

	            @Override

	            public void partDeactivated(IWorkbenchPart part) {

	                // TODO Auto-generated method stub

	            }

	            @Override

	            public void partClosed(IWorkbenchPart part) {

	            	if(part.equals(editor))	{

	            		// FIXME: Debug

		            	//System.out.println("ChartEditor.addLinkedEditor(...).new IPartListener() {...}.partClosed()");

		                // TODO Auto-generated method stub

		            	removeLinkedEditor(editor);

		            	editor.getSite().getPage().removePartListener(this);

	            	}

	            }

	            @Override

	            public void partBroughtToTop(IWorkbenchPart part) {

	                // TODO Auto-generated method stub

	            }

	            @Override

	            public void partActivated(IWorkbenchPart part) {

	                // TODO Auto-generated method stub

	            }

	        });

		}

	}

	/**

	 * Unlinks the specified editor from this editor.

	 * @param editor

	 */

	//FIXME: should be at TXMEditor level

	public void removeLinkedEditor(EditorPart editor)	{

		if(this.linkedEditors != null)	{

			if(this.linkedEditors.remove(editor))	{

				// FIXME: debug

				//System.err.println(this.getClass().getSimpleName() + ": A linked editor of type \"" + editor.getClass().getSimpleName() + "\" has been removed from this one. Linked editors count: " + this.linkedEditors.size() + ".");

			}

		}

		if(this.linkedEditors.isEmpty())	{

			this.linkedEditors = null;	

		}

	}

	/**

	 * Gets the linked editors to this one if exist.

	 * @return

	 */

	//FIXME: should be at TXMEditor level

	public ArrayList<EditorPart> getLinkedEditors()	{

		return this.linkedEditors;

	}

	/**

	 * Gets the first linked editor of the specified class if exists.

	 * @param editorClass

	 * @return

	 */

	//FIXME: should be at TXMEditor level

	public EditorPart getLinkedEditor(Class editorClass)	{

		EditorPart editor = null;

		if(this.linkedEditors != null) {

			for(int i = 0; i < this.linkedEditors.size(); i++) {

				if(this.linkedEditors.get(i).getClass().equals(editorClass)) {

					editor = this.linkedEditors.get(i);

					break;

				}

			}

		}

		return editor;

	}

	/**

	 * Gets the linked editors of the specified class if exist otherwise returns an empty list.

	 * @param editorClass

	 * @return

	 */

	//FIXME: should be at TXMEditor level

	public ArrayList<EditorPart> getLinkedEditors(Class editorClass)	{

		ArrayList<EditorPart> editors = new ArrayList<EditorPart>();

		if(this.linkedEditors != null) {

			for(int i = 0; i < this.linkedEditors.size(); i++) {

				if(this.linkedEditors.get(i).getClass().equals(editorClass)) {

					editors.add(this.linkedEditors.get(i));

				}

			}

		}

		return editors;

	}

	// FIXME: useless ?

//	/**

//	 * Gets the first linked editor linked to the specified editor input.

//	 * @param editorClass

//	 * @return

//	 */

//	public EditorPart getLinkedEditor(IEditorInput editorInput)	{

//		EditorPart editor = null;

//		if(this.linkedEditors != null) {

//			for(int i = 0; i < this.linkedEditors.size(); i++) {

//				if(this.linkedEditors.get(i).getEditorInput().equals(editorInput)) {

//					editor = this.linkedEditors.get(i);

//					break;

//				}

//			}

//		}

//		return editor;

//	}

	/**

			// Custom XYSplineRenderer selection renderer

			//plot.setRenderer(this.theme.createXYSplineRenderer(linesVisible, shapesVisible));

			// FIXME : tests for curves

		// FIXME: Apply theme to the chart

		//this.theme.apply(chart);

//

//	@Override

//	public File createCAH2dChartFile(CAH cah, File file) {

//		return this.export(this.createCAH2dChart(cah), file);

//	}

//

//

//	@Override

//	public JFreeChart createCAH3dChart(CAH cah) {

//		// FIXME : tests CAH 3d

//		return null;

//	}

//

//

//	@Override

//	public File createCAH3dChartFile(CAH cah, File file) {

//		return this.export(this.createCAH3dChart(cah), file);

//	}

//	@Override

//	public JFreeChart createPartitionDimensionsChart(Partition partition, boolean sortPartsBySize) {

//

//		JFreeChart chart = null;

//

//

//		// FIXME: XYBarPlot and test symbol axis

//		try {

//			// Creating the data set from the partition result

//			XYSeriesCollection dataset = new XYSeriesCollection();

//

//			XYSeries series = new XYSeries(ChartsEngineMessages.ChartsEngine_PARTITION_DIMENSIONS_CATEGORY);

//			dataset.addSeries(series);

//

//			List<Part> parts;

//

//			// Sort parts by descendant size order

//			if (sortPartsBySize) {

//				parts = partition.getPartsSortedBySize();

//			}

//			// Default parts order

//			else	{

//				parts = partition.getParts();

//			}

//

//

//	        String[] xAxisSymbols = new String[parts.size()];

//

//

//			for (int i = 0 ; i < parts.size() ; i++) {

//				series.add(i, parts.get(i).getSize());

//

//				// Add X axis symbol

//				xAxisSymbols[i] = parts.get(i).getName();

//			}

//

//			// Create chart title

//			String title = this.createPartitionDimensionsChartTitle(partition, sortPartsBySize);

//

//			// Create the chart

//	        chart = this.createXYBarChart(dataset, title, ChartsEngineMessages.ChartsEngine_PARTITION_DIMENSIONS_X_AXIS_LABEL, ChartsEngineMessages.ChartsEngine_PARTITION_DIMENSIONS_Y_AXIS_LABEL, false, true, false, xAxisSymbols);

//	        ((IItemSelectionRenderer) chart.getXYPlot().getRenderer()).setChartType(ChartsEngine.CHART_TYPE_PARTITION_DIMENSIONS);

//

//

//	        // Custom range axis for ticks drawing options

//	        chart.getXYPlot().setRangeAxis(new ExtendedNumberAxis((NumberAxis) chart.getXYPlot().getRangeAxis(), false, true, 0, DatasetUtilities.findMaximumRangeValue(chart.getXYPlot().getDataset()).doubleValue()));

//

//	        this.theme.apply(chart);

//

//		}

//		catch(CqiClientException e) {

//			// TODO Auto-generated catch block

//			e.printStackTrace();

//		}

//

//

//

//		// FIXME: Category bar plot

////		try {

////			// Creating the data set from the partition result

////			DefaultCategoryDataset dataset = new DefaultCategoryDataset();

////			String category = ChartsEngineMessages.ChartsEngine_PARTITION_DIMENSIONS_CATEGORY;

////

////

////			List<Part> parts;

////

////			// Sort parts by descendant size order

////			if (sortPartsBySize) {

////				parts = partition.getPartsSortedBySize();

////			}

////			// Default parts order

////			else	{

////				parts = partition.getParts();

////			}

////

////			for (int i = 0 ; i < parts.size() ; i++) {

////				dataset.setValue(parts.get(i).getSize(), category, parts.get(i).getName());

////			}

////

////			// Create chart title

////			String title = this.createPartitionDimensionsChartTitle(partition, sortPartsBySize);

////

////			// Create the chart

////	        chart = this.createCategoryBarChart(dataset, title, ChartsEngineMessages.ChartsEngine_PARTITION_DIMENSIONS_X_AXIS_LABEL, ChartsEngineMessages.ChartsEngine_PARTITION_DIMENSIONS_Y_AXIS_LABEL, false, true);

////	        ((IItemSelectionRenderer) chart.getCategoryPlot().getRenderer()).setChartType(ChartsEngine.CHART_TYPE_PARTITION_DIMENSIONS);

////

////

////	        // Custom range axis for ticks drawing options

////	        chart.getCategoryPlot().setRangeAxis(new ExtendedNumberAxis((NumberAxis) chart.getCategoryPlot().getRangeAxis(), false, true, 0, DatasetUtilities.findMaximumRangeValue(chart.getCategoryPlot().getDataset()).doubleValue()));

////

////		}

////		catch(CqiClientException e) {

////			// TODO Auto-generated catch block

////			e.printStackTrace();

////		}

//

//

//

//

//		return chart;

//	}

//

//

//	@Override

//	public File createPartitionDimensionsChartFile(Partition partition, boolean sortPartsBySize, File file) {

//		return this.export(this.createPartitionDimensionsChart(partition, sortPartsBySize), file);

//	}

//	@Override

//	public JFreeChart createSpecificitiesChart(SpecificitesResult specificitiesResult, boolean transpose, boolean drawBars, boolean drawLines, float banality, boolean grayscale) {

//

//		JFreeChart chart = null;

//

//

//		// FIXME: XY bar chart version

//		// Create the data set

//		final XYSeriesCollection dataset = new XYSeriesCollection();

//

//

//		String[] xAxisSymbols;

//

//		// Transpose the data set

//		if(transpose)	{

//	        xAxisSymbols = new String[specificitiesResult.getSelectedTypeNames().length];

//

//			for(int i = 0; i < specificitiesResult.getSelectedPartNames().length; i++) {

//				XYSeries series = new XYSeries(specificitiesResult.getSelectedPartNames()[i]);

//				dataset.addSeries(series);

//

//

//				for(int j = 0; j < specificitiesResult.getSelectedTypeNames().length; j++) {

//					series.add(j, specificitiesResult.getSelectedSpecificitiesIndex()[j][i]);

//					// Add X axis symbol

//					xAxisSymbols[j] = specificitiesResult.getSelectedTypeNames()[j];

//				}

//			}

//

//		}

//		else {

//	        xAxisSymbols = new String[specificitiesResult.getSelectedPartNames().length];

//

//			for(int i = 0; i < specificitiesResult.getSelectedTypeNames().length; i++) {

//

//				XYSeries series = new XYSeries(specificitiesResult.getSelectedTypeNames()[i]);

//				dataset.addSeries(series);

//

//				for(int j = 0; j < specificitiesResult.getSelectedPartNames().length; j++) {

//					series.add(j, specificitiesResult.getSelectedSpecificitiesIndex()[i][j]);

//					// Add X axis symbol

//					xAxisSymbols[j] = specificitiesResult.getSelectedPartNames()[j];

//				}

//			}

//		}

//

//        if(drawBars)	{

//			// Create the bar chart

//	        chart = this.createXYBarChart(dataset, specificitiesResult.getName(), ChartsEngineMessages.ChartsEngine_SPECIFICITIES_X_AXIS_LABEL, ChartsEngineMessages.ChartsEngine_SPECIFICITIES_Y_AXIS_LABEL, true, false, false, xAxisSymbols);

//        }

//        else	{

//			// Create the line chart

//	        chart = this.createXYLineChart(dataset, specificitiesResult.getName(), ChartsEngineMessages.ChartsEngine_SPECIFICITIES_X_AXIS_LABEL, ChartsEngineMessages.ChartsEngine_SPECIFICITIES_Y_AXIS_LABEL,

//	        		true, false, true, true, true, false, false, xAxisSymbols);

//        }

//

//        ((IItemSelectionRenderer) chart.getXYPlot().getRenderer()).setChartType(ChartsEngine.CHART_TYPE_SPECIFICITIES);

//

//

//        // Custom range axis for ticks drawing options

//        double minimumValue = DatasetUtilities.findMinimumRangeValue(chart.getXYPlot().getDataset()).doubleValue();

//        double maximumValue = DatasetUtilities.findMaximumRangeValue(chart.getXYPlot().getDataset()).doubleValue();

//        // Adjust ticks values according to data set contains only positives values or only negatives values

//        if(minimumValue > 0)	{

//        	minimumValue = 0;

//        }

//        if(maximumValue < 0)	{

//        	maximumValue = banality;

//        }

//

//        // Custom range axis to cut the values to minimum and maximum values

//        chart.getXYPlot().setRangeAxis(new ExtendedNumberAxis((NumberAxis) chart.getXYPlot().getRangeAxis(), true, true, minimumValue, maximumValue));

//

//

//        // Add positive banality marker

//        Marker marker = new ValueMarker(banality);

//        marker.setPaint(Color.red);

//        marker.setLabel(JFreeChartsEngineMessages.bind(ChartsEngineMessages.ChartsEngine_SPECIFICITIES_BANALITY_MARKER_LABEL, banality));

//        marker.setLabelAnchor(RectangleAnchor.TOP_RIGHT);

//        marker.setLabelTextAnchor(TextAnchor.BOTTOM_RIGHT);

//        chart.getXYPlot().addRangeMarker(marker);

//

//

//        // Add negative banality marker

//        marker = new ValueMarker(-banality);

//        marker.setPaint(Color.red);

//        marker.setLabel(JFreeChartsEngineMessages.bind(ChartsEngineMessages.ChartsEngine_SPECIFICITIES_BANALITY_MARKER_LABEL, -banality));

//        marker.setLabelAnchor(RectangleAnchor.TOP_RIGHT);

//        marker.setLabelTextAnchor(TextAnchor.BOTTOM_RIGHT);

//        chart.getXYPlot().addRangeMarker(marker);

//

//

//

//		// FIXME: Category bar chart version

////		// Create the data set

////		final DefaultCategoryDataset dataset = new DefaultCategoryDataset();

////

////		// Transpose the data set

////		if(transpose)	{

////			for(int i = 0; i < specificitiesResult.getSelectedTypeNames().length; i++) {

////				for(int j = 0; j < specificitiesResult.getSelectedPartNames().length; j++) {

////					dataset.addValue(specificitiesResult.getSelectedSpecificitiesIndex()[i][j],

////							specificitiesResult.getSelectedPartNames()[j],

////							specificitiesResult.getSelectedTypeNames()[i]);

////				}

////			}

////		}

////		else {

////			for(int i = 0; i < specificitiesResult.getSelectedPartNames().length; i++) {

////				for(int j = 0; j < specificitiesResult.getSelectedTypeNames().length; j++) {

////					dataset.addValue(specificitiesResult.getSelectedSpecificitiesIndex()[j][i],

////							specificitiesResult.getSelectedTypeNames()[j],

////							specificitiesResult.getSelectedPartNames()[i]);

////				}

////			}

////		}

////

////        if(drawBars)	{

////			// Create the bar chart

////	        chart = this.createCategoryBarChart(dataset, specificitiesResult.getName(), ChartsEngineMessages.ChartsEngine_SPECIFICITIES_X_AXIS_LABEL, ChartsEngineMessages.ChartsEngine_SPECIFICITIES_Y_AXIS_LABEL, true, false);

////        }

////        else	{

////			// Create the line chart

////	        chart = this.createCategoryLineChart(dataset, specificitiesResult.getName(), ChartsEngineMessages.ChartsEngine_SPECIFICITIES_X_AXIS_LABEL, ChartsEngineMessages.ChartsEngine_SPECIFICITIES_Y_AXIS_LABEL, true, false);

////        }

////        ((IItemSelectionRenderer) chart.getCategoryPlot().getRenderer()).setChartType(ChartsEngine.CHART_TYPE_SPECIFICITIES);

////

////

////        // Custom range axis for ticks drawing options

////        double minimumValue = DatasetUtilities.findMinimumRangeValue(chart.getCategoryPlot().getDataset()).doubleValue();

////        double maximumValue = DatasetUtilities.findMaximumRangeValue(chart.getCategoryPlot().getDataset()).doubleValue();

////        // Adjust ticks values according to data set contains only positives values or only negatives values

////        if(minimumValue > 0)	{

////        	minimumValue = 0;

////        }

////        if(maximumValue < 0)	{

////        	maximumValue = banality;

////        }

////

////        // Custom range axis to cut the values to minimum and maximum values

////        chart.getCategoryPlot().setRangeAxis(new ExtendedNumberAxis((NumberAxis) chart.getCategoryPlot().getRangeAxis(), true, true, minimumValue, maximumValue));

////

////

////        // Add positive banality marker

////        Marker marker = new ValueMarker(banality);

////        marker.setPaint(Color.red);

////        marker.setLabel(JFreeChartsEngineMessages.bind(ChartsEngineMessages.ChartsEngine_SPECIFICITIES_BANALITY_MARKER_LABEL, banality));

////        marker.setLabelAnchor(RectangleAnchor.TOP_RIGHT);

////        marker.setLabelTextAnchor(TextAnchor.BOTTOM_RIGHT);

////        chart.getCategoryPlot().addRangeMarker(marker);

////

////

////        // Add negative banality marker

////        marker = new ValueMarker(-banality);

////        marker.setPaint(Color.red);

////        marker.setLabel(JFreeChartsEngineMessages.bind(ChartsEngineMessages.ChartsEngine_SPECIFICITIES_BANALITY_MARKER_LABEL, -banality));

////        marker.setLabelAnchor(RectangleAnchor.TOP_RIGHT);

////        marker.setLabelTextAnchor(TextAnchor.BOTTOM_RIGHT);

////        chart.getCategoryPlot().addRangeMarker(marker);

//

//

//        int itemsColorsRenderingMode = ChartsEngine.RENDERING_COLORS_MODE;

//		// Grayscale

//        if(grayscale)	{

//        	itemsColorsRenderingMode = ChartsEngine.RENDERING_GRAYSCALE_MODE;

//        }

//

//        // Re-apply theme to the chart to match the colors rendering mode

//        // FIXME : the rendering mode should be pass to all methods, even base methods as createXYLineChart(), createBarChart(), etc.

//		this.theme.applyThemeToChart(chart, itemsColorsRenderingMode);

//

//		return chart;

//	}

//	@Override

//	public File createSpecificitiesChartFile(SpecificitesResult specificitiesResult, boolean transpose, boolean drawBars, boolean drawLines, float banalite, boolean grayscale, File file) {

//		return this.export(this.createSpecificitiesChart(specificitiesResult, transpose, drawBars, drawLines, banalite, grayscale), file);

//	}

//	@Override

//	public JFreeChart createProgressionChart(Progression progression, boolean grayscale, boolean monostyle, boolean cumulative) {

//

//		JFreeChart chart = null;

//

//		// Create the dataset

//		XYSeriesCollection dataset = new XYSeriesCollection();

//		List<int[]> positions = progression.getAllpositions();

//		List<Query> queries = progression.getQueries();

//		// Y axis label

//		String yAxisLabel;

//

//		// Cumulative

//		if(cumulative)	{

//			for(int i = 0; i < progression.getAllpositions().size(); i++) {

//				int[] list = positions.get(i);

//				Query query = queries.get(i);

//				XYSeries series = new XYSeries(query.toString() + " " + list.length);

//				int c = 1;

//				for(int j = 0; j < list.length; j++) {

//					// Add a first point to draw a vertical line

//					if(j == 0)	{

//						series.add(list[j], 0);

//					}

//					series.add(list[j], c++);

//				}

//

//				// FIXME: add a dummy point to draw horizontal line between last point and max X corpus

//				series.add(progression.getXmaxCorpus(), --c);

//				dataset.addSeries(series);

//			}

//

//			// Create the chart

//			yAxisLabel = ChartsEngineMessages.ChartsEngine_PROGRESSION_Y_AXIS_CUMULATIVE_LABEL;

//			chart = this.createXYStepChart(dataset, this.createProgressionChartTitle(progression, cumulative),

//					JFreeChartsEngineMessages.bind(ChartsEngineMessages.ChartsEngine_PROGRESSION_X_AXIS_LABEL, progression.getXmaxCorpus()), yAxisLabel, true, true, true, true, true);

//

//

//			// Custom renderer

//			chart.getXYPlot().setRenderer(this.theme.createProgressionRenderer());

//

//		}

//		// FIXME : Density, to implement when textometry R package will store the result in the Progression class

//		else	{

//

//			// FIXME : density not yet implemented

//			System.err.println("JFCChartsEngine.createProgressionChart(): density mode not yet implemented.");

//

//			for(int i = 0; i < progression.getAllpositions().size(); i++) {

//				int[] liste = positions.get(i);

//				Query query = queries.get(i);

//				XYSeries series = new XYSeries(query.toString() + " " + liste.length);

//

//				for(int j = 0; j <  liste.length; j++) {

//

//					// FIXME : tests y

//					// y <- c( c(0), y , c(y[[length(x)]]) ) // R code

//					// FIXME : random Y value

//					double y = progression.getAllpositions().get(i)[j] * Math.random();

//	//				double y = progression.getAllpositions().get(i)[j];

//					series.add(liste[j], y);

//				}

//				dataset.addSeries(series);

//			}

//

//			// Create the chart

//			yAxisLabel =  ChartsEngineMessages.ChartsEngine_PROGRESSION_Y_AXIS_NOT_CUMULATIVE_LABEL;

//			chart = this.createXYLineChart(dataset, this.createProgressionChartTitle(progression, cumulative),

//					JFreeChartsEngineMessages.bind(ChartsEngineMessages.ChartsEngine_PROGRESSION_X_AXIS_LABEL, progression.getXmaxCorpus()), yAxisLabel,

//					true, true, true, false, true, false, true, null);

//		}

//

//

//

//        ((IItemSelectionRenderer) chart.getXYPlot().getRenderer()).setChartType(ChartsEngine.CHART_TYPE_PROGRESSION);

//        ((IItemSelectionRenderer) chart.getXYPlot().getRenderer()).getItemsSelector().setResultData(progression);

//

//

//		// Add the limit markers

//		BasicStroke dashedStroke = new BasicStroke(0.5f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 1f, new float[] {2f}, 0f);

//		Marker marker = new ValueMarker(progression.getXminCorpus());

//        marker.setPaint(Color.gray);

//        marker.setStroke(dashedStroke);

//        chart.getXYPlot().addDomainMarker(marker);

//		marker = new ValueMarker(progression.getXmaxCorpus());

//        marker.setPaint(Color.gray);

//        marker.setStroke(dashedStroke);

//        chart.getXYPlot().addDomainMarker(marker);

//

//

////        // FIXME : limit with annotations rather than markers (marker height is dynamically adapted to the real chart height.

//        // Annotation have a fixed height)

////        XYLineAnnotation annotation = new XYLineAnnotation(0, 0, 0, dataset.getRangeUpperBound(true), dashedStroke, Color.gray);

////        chart.getXYPlot().addAnnotation(annotation, true);

//

//		// Add the part markers

//		if(progression.getStructurePositions().length > 0)	{

//			for(int i = 0; i < progression.getStructurePositions().length; i++) {

//				if(progression.getStructurePositions()[i] != 0)	{

//					marker = new ValueMarker(progression.getStructurePositions()[i]);

//			        marker.setPaint(Color.black);

//			        marker.setLabel(progression.getStructureNames()[i]);

//			        marker.setLabelAnchor(RectangleAnchor.TOP_RIGHT);

//			        marker.setLabelTextAnchor(TextAnchor.HALF_ASCENT_LEFT);

//

//

//			        // FIXME: test of rotated annotations rather than using marker label. The problem with this is that the position of annotation is not adjusted when zooming/dezooming.

//			        // FIXME: the best approach is to redefine the drawing method of

//////			        double start = marker.getStartValue();

//////			        double end = TempIntervalMarker.getEndValue();

//////			        double middle = (end - start)/2;

////			        XYTextAnnotation updateLabel = new XYTextAnnotation("Update", progression.getStructurePositions()[i], 0);

////			        updateLabel.setFont(new Font("Sans Serif", Font.BOLD, 10));

////			        updateLabel.setRotationAnchor(TextAnchor.BASELINE_CENTER);

////			        updateLabel.setTextAnchor(TextAnchor.BASELINE_CENTER);

////			        updateLabel.setRotationAngle(3.14 / 2);

////			        updateLabel.setPaint(Color.black);

////			        chart.getXYPlot().addAnnotation(updateLabel);

//

//

//

//			        chart.getXYPlot().addDomainMarker(marker);

//				}

//			}

//		}

//

//		// Custom domain axis for ticks drawing options

//		chart.getXYPlot().setDomainAxis(new ExtendedNumberAxis((NumberAxis) chart.getXYPlot().getDomainAxis(), true, true, progression.getXminCorpus(), progression.getXmaxCorpus()));

//

//		// Custom range axis for ticks drawing options

//		chart.getXYPlot().setRangeAxis(new ExtendedNumberAxis((NumberAxis) chart.getXYPlot().getRangeAxis(), false, true, 0, progression.getMaxY()));

//

//		// Match the X-axis origin value to the min x corpus (for subcorpus case)

//		chart.getXYPlot().getDomainAxis().setLowerBound(progression.getXminCorpus());

//

//

//        int itemsColorsRenderingMode = Theme.ITEMS_RENDERING_COLORS_MODE;

//		// Grayscale

//        if(grayscale)	{

//        	itemsColorsRenderingMode = Theme.ITEMS_RENDERING_GRAYSCALE_MODE;

//        }

//

//        // Re-apply theme to the chart to match the colors rendering mode

//        // FIXME : the rendering mode should be pass to all methods, even base methods as createXYLineChart(), createBarChart(), etc.

//        // or better, to be stocked into a member variable in the theme ?

//		this.theme.applyThemeToChart(chart, itemsColorsRenderingMode, monostyle);

//

//		return chart;

//	}

//

//	@Override

//	public File createProgressionChartFile(Progression progression, boolean grayscale, boolean monostyle, boolean cumulative, File file) {

//		return this.export(this.createProgressionChart(progression, grayscale, monostyle, cumulative), file);

//	}

	// FIXME : enhance this method to add compression mode and quality, see : ImageIO.getImageWritersByFormatName("jpg") for that

// FIXME: old version

//	/**

//	 * Constrains axes ticks to square aspect ratio.

//	 * @param width

//	 * @param height

//	 */

//	public void squareOffGraph(JFreeChart chart, double width, double height) {

//

//		if(getChart().getPlot() instanceof XYPlot)	{

//

//			ValueAxis xAxis = ((XYPlot)getChart().getPlot()).getDomainAxis(0);

//			ValueAxis yAxis = ((XYPlot)getChart().getPlot()).getRangeAxis(0);

//

//			double xLower = xAxis.getLowerBound();

//			double xUpper = xAxis.getUpperBound();

//

//			double yLower = yAxis.getLowerBound();

//			double yUpper = yAxis.getUpperBound();

//

//			if(width > height) {

//				double idealXRange = (yUpper - yLower) * width / height;

//				double currXRange  =  xUpper - xLower;

//

//				double xDelta = (idealXRange - currXRange) / 2;

//

//				// Are we within a pixel of being square?

//				if ((int)(xDelta * width) == 0) {

//					return;

//				}

//

//				xAxis.setLowerBound(xLower - xDelta);

//				xAxis.setUpperBound(xUpper + xDelta);

//			}

//			else if(height > width)	{

//				double idealYRange = (xUpper - xLower) * height / width;

//				double currYRange  =  yUpper - yLower;

//

//				double yDelta = (idealYRange - currYRange) / 2;

//

//				// Are we within a pixel of being square?

//				if ((int)(yDelta * height) == 0) {

//					return;

//				}

//

//				yAxis.setLowerBound(yLower - yDelta);

//				yAxis.setUpperBound(yUpper + yDelta);

//			}

//		}

//	}

	// FIXME: unit aspect ratio constraint tests

//	public void squareOffGraph2(JFreeChart chart) {

//

//		if(getChart().getPlot() instanceof XYPlot)	{

//		XYPlot plot = (XYPlot) getChart().getPlot();

//		ValueAxis domainAxis = plot.getDomainAxis();

//		Rectangle2D dataArea = getScreenDataArea();

//        ValueAxis rangeAxis = plot.getRangeAxis();

//

//		// Now modify axes ranges to ensure aspect ratio is 1

//        double rl = rangeAxis.getRange().getLowerBound();

//        double ru = rangeAxis.getRange().getUpperBound();

//

//        double rls = rangeAxis.valueToJava2D(rl, dataArea, plot.getRangeAxisEdge());

//        double rus = rangeAxis.valueToJava2D(ru, dataArea, plot.getRangeAxisEdge());

//

////        double rangeratio = Math.abs((rus - rls) / (ru - rl));

//

//        double dl = domainAxis.getRange().getLowerBound();

//        double du = domainAxis.getRange().getUpperBound();

//        double dls = domainAxis.valueToJava2D(dl, dataArea, plot.getDomainAxisEdge());

//        double dus = domainAxis.valueToJava2D(du, dataArea, plot.getDomainAxisEdge());

//

//      //  System.out.println("ItemSelectionXYLineAndShapeRenderer.drawSecondaryPass(): " + (rls - rus));

//

////        double domainratio = Math.abs((dus - dls) / (du - dl));

////

////        // precision limit to ensure we don't keep rendering

////        double eps = 1.01;

////        if (rangeratio / domainratio > eps) {

////            rangeAxis.setAutoRange(false);

////            double totalrange = Math.abs(ru - rl) * rangeratio / domainratio;

////            double l = (ru - rl) / 2 - totalrange / 2;

////            double u = (ru - rl) / 2 + totalrange / 2;

////            rangeAxis.setRange(new Range(l, u));

////        } else if (domainratio / rangeratio > eps) {

////            domainAxis.setAutoRange(false);

////            double totalrange = Math.abs(du - dl) * domainratio / rangeratio;

////            double l = (du - dl) / 2 - totalrange / 2;

////            double u = (du - dl) / 2 + totalrange / 2;

////            domainAxis.setRange(new Range(l, u));

////        }

//

//

//        double xPixelsWidth = Math.abs(dus + dls);

//        double yPixelsHeight = Math.abs(rus + rls);

//

//		// FIXME: tests 3

//		//System.out.println("ItemSelectionXYLineAndShapeRenderer.drawSecondaryPass(): " + getPlot().getRangeAxis().getFixedDimension());

//

//       //System.out.println("ItemSelectionXYLineAndShapeRenderer.drawSecondaryPass(): xPixelsWidth " + xPixelsWidth);

//

//

//

//        if(rangeAxis.getRange().getLength() > domainAxis.getRange().getLength())	{

//

//            // Shrink X axis pixels width

//        	if(xPixelsWidth > yPixelsHeight)	{

//

//	        	double newPixelsWidth = plot.getDomainAxis().getRange().getLength() * yPixelsHeight / plot.getRangeAxis().getRange().getLength();

//

//	        	xPixelsWidth = (xPixelsWidth - newPixelsWidth) / 2;

//

//

//	        	//System.out.println("ItemSelectionXYLineAndShapeRenderer.drawSecondaryPass() newPixelsWidth : " + newPixelsWidth);

//

//	        	// FIXME: axis space version

//	            AxisSpace xAxisSpace = new AxisSpace();

//	            xAxisSpace.add(xPixelsWidth, plot.getRangeAxisEdge());

//	            xAxisSpace.add(xPixelsWidth, plot.getRangeAxisEdge(1));

//	            // xAxisSpace.shrink(new Rectangle2D.Double(50, 0, 20, 50), null);

//	            plot.setFixedRangeAxisSpace(xAxisSpace);

//

//	            // FIXME: insets version

//	            // double top, double left, double bottom, double right

////	            plot.setInsets(new RectangleInsets(plot.getInsets().getTop(), xPixelsWidth, plot.getInsets().getBottom(), xPixelsWidth));

//

//        		// FIXME: auto range tests

//	        	//plot.getRangeAxis().setAutoRange(false);

//	        	//plot.getRangeAxis().setAutoRangeMinimumSize(200);

//

//        	}

//            // Shrink Y axis pixels height

//        	else

//        		if(yPixelsHeight > xPixelsWidth)	{

//

//        		double newPixelsHeight = plot.getRangeAxis().getRange().getLength() * xPixelsWidth / plot.getDomainAxis().getRange().getLength();

//

//        		yPixelsHeight = (yPixelsHeight - newPixelsHeight) / 2;

//

//        		//System.out.println("ItemSelectionXYLineAndShapeRenderer.drawSecondaryPass() newPixelsHeight : " + newPixelsHeight);

//

//	        	// FIXME: axis space version

//	            AxisSpace yAxisSpace = new AxisSpace();

//	            yAxisSpace.add(yPixelsHeight, plot.getDomainAxisEdge());

//	            yAxisSpace.add(yPixelsHeight, plot.getDomainAxisEdge(1));

//	            plot.setFixedDomainAxisSpace(yAxisSpace);

//

//	            // FIXME: insets version

//	            // double top, double left, double bottom, double right

////	            plot.setInsets(new RectangleInsets(yPixelsHeight, plot.getInsets().getLeft(), yPixelsHeight, plot.getInsets().getRight()));

//

//        		// FIXME: auto range tests

//        		//plot.getDomainAxis().setAutoRange(false);

//        		//plot.getDomainAxis().setAutoRangeMinimumSize(200);

//        	}

//        }

//		}

//	}

	// FIXME: unit aspect ratio constraint tests

//	public void squareOffGraph3(JFreeChart chart)	{

//		ValueAxis rangeAxis = getChart().getXYPlot().getRangeAxis();

//		ValueAxis domainAxis = getChart().getXYPlot().getDomainAxis();

//		//Rectangle2D dataArea = new Rectangle2D.Double(0,  0,  1600, 500);

//		Rectangle2D dataArea = new Rectangle2D.Double(0,  0,  getWidth(), getHeight());

//		//Rectangle2D dataArea = getScreenDataArea();

//

//		double rl = rangeAxis.getRange().getLowerBound();

//        double ru = rangeAxis.getRange().getUpperBound();

//

//        double rls = rangeAxis.valueToJava2D(rl, dataArea,

//        		getChart().getXYPlot().getRangeAxisEdge());

//        double rus = rangeAxis.valueToJava2D(ru, dataArea,

//        		getChart().getXYPlot().getRangeAxisEdge());

//

//        double rangeratio = Math.abs((rus - rls) / (ru - rl));

//

//        double dl = domainAxis.getRange().getLowerBound();

//        double du = domainAxis.getRange().getUpperBound();

//

//        double dls = domainAxis.valueToJava2D(dl, dataArea,

//        		getChart().getXYPlot().getDomainAxisEdge());

//        double dus = domainAxis.valueToJava2D(du, dataArea,

//        		getChart().getXYPlot().getDomainAxisEdge());

//        double domainratio = Math.abs((dus - dls) / (du - dl));

//

//        // precision limit to ensure we don't keep rendering

//        double eps = 1.01;

//        if (rangeratio / domainratio > eps) {

//            rangeAxis.setAutoRange(false);

//            double totalrange = Math.abs(ru - rl) * rangeratio / domainratio;

//            double l = (ru - rl) / 2 - totalrange / 2;

//            double u = (ru - rl) / 2 + totalrange / 2;

//            rangeAxis.setRange(new Range(l, u));

//        } else if (domainratio / rangeratio > eps) {

//            domainAxis.setAutoRange(false);

//            double totalrange = Math.abs(du - dl) * domainratio / rangeratio;

//            double l = (du - dl) / 2 - totalrange / 2;

//            double u = (du - dl) / 2 + totalrange / 2;

//            domainAxis.setRange(new Range(l, u));

//        }

//	}

			// FIXME: using new file

			//this.createChartFile(result, preferencesNode);

                	// FIXME: ratio tests for label truncation system in partition dimensions and specificities

                	//l -= getPlot().getInsets().getBottom();

        		// FIXME : xDecals computing bug if category margin is different from 0

        		// the code below doesn't fix the problem

//        		xDecals -= dataArea.getWidth() * getCategoryMargin() / categoriesCount;

//        		xDecals -= dataArea.getWidth() * getCategoryMargin() / categoriesCount;

        	// TODO : First tick, see compatibility with setLowerMargin(), the lower margin value must be computed here else, for example if the lower value = 0, the first tick will be outside of the chart

//        	if(categoriesCount > 0)	{

//        		//x = dataArea.getMinX() + xDecals;

//        		x = getCategoryStart(0, categoriesCount, dataArea, edge) - xDecals;

//                line.setLine(x, cursor, x, cursor - il);

//                g2.draw(line);

//                line.setLine(x, cursor, x, cursor + ol);

//                g2.draw(line);

//        	}

Require-Bundle: org.txm.libs.jfreechart;bundle-version="1.0.17";visibility:=reexport,

 org.txm.libs.jfreesvg;bundle-version="1.7.0";visibility:=reexport,

 org.txm.chartsengine.core;bundle-version="1.0.0";visibility:=reexport

	//FIXME move/replace this to a link / with a command call

//	public Object toConcordance(){

//		String query = buildQuery();

//		if (query == null) return null;

//

//		Concordance concordance = new Concordance(corpus);

//		concordance.setParameters(new Query(query), null, null, null, null, null, null, null, null, null, null);

//		TXMResultEditorInput editorInput = new TXMResultEditorInput(concordance);

//		IWorkbenchPage page = this.getSite().getPage();

//		try {

//			ConcordanceEditor conceditor = (ConcordanceEditor) page

//					.openEditor(editorInput, "ConcordanceEditor"); //$NON-NLS-1$

//			return conceditor;

//		} catch (PartInitException e) {

//			System.err.println(NLS.bind(Messages.GetConcordances_4, e));

//		}

//		return null;

//	}

//

//	public Object toIndex() {

//		String query = buildQuery();

//		if (query == null) return null;

//		try {

//			Index index = new Index(corpus);

//			index.setParameters(new Query(query), Arrays.asList(corpus.getWordProperty()), null, null, null, null);

//			TXMResultEditorInput editorInput = new TXMResultEditorInput(index);

//			IWorkbenchPage page = this.getSite().getPage();

//

//			IndexEditor voceditor = (IndexEditor) page

//					.openEditor(editorInput,

//							"org.txm.rcp.editors.index.IndexEditor"); //$NON-NLS-1$

//			voceditor.setFocus(query);

//			voceditor.computeResult();

//			return voceditor;

//		} catch (Exception e) {

//			System.err.println(NLS.bind(Messages.GetConcordances_4, e));

//		}

//		return null;

//	}

import org.txm.searchengine.cqp.corpus.query.Query;

	//protected int lastConcordanceBottomLine = -1;

//FIXME: version with TXMBrowser old system edition

//	@Override

//	public void processEvent(final AWTEvent event, final int eventArea, final Object o) {

//		

//		// Need to run this in the SWT UI thread because it's called from the AWT UI thread in TBX charts engine layer

//		chartEditor.getComposite().getDisplay().asyncExec(new Runnable() {

//			public void run() {

//

//				// Mouse event

//				if(event instanceof MouseEvent)	{

//				

//					MouseEvent mouseEvent = (MouseEvent)event;

//					

//					//return if it's not the left mouse button

//					if(mouseEvent.getButton() != MouseEvent.BUTTON1)	{

//						return;

//					}

//					

//					

//					ChartMouseEvent chartEvent = (ChartMouseEvent) o;

//					ChartEntity entity = chartEvent.getEntity();

//					final ArrayList<Integer> selectedPointPositions = Utils.getChartCreator(chartEditor.getChartsEngine()).getSelectedPointPositions(chartEditor.getChart());

//	

//					if(event.getID() == MouseEvent.MOUSE_CLICKED && mouseEvent.getClickCount() == 2 && eventArea == EventCallBack.AREA_ITEM && !selectedPointPositions.isEmpty()) {

//	

//						// Linked edition (CTRL/CMD + double click)

//						if((mouseEvent.getModifiers() & ZoomAndPanCallBack.keyboardZoomModifierKeyMask) != 0) {

//							// Updates the linked editor

//							updateLinkedEditionEditor((TXMBrowser) chartEditor.getLinkedEditor(TXMBrowser.class), selectedPointPositions);

//						}

//						// Linked concordance

//						else	{

//							// Updates the linked editor

//							updateLinkedConcordanceEditor(chartEditor.getLinkedEditors(ConcordanceEditor.class), selectedPointPositions);

//						}

//					}

//					else if(event.getID() == MouseEvent.MOUSE_CLICKED && mouseEvent.getClickCount() == 1 && eventArea == EventCallBack.AREA_ITEM) {

//

//						// Get the linked concordance editors and update the one linked to the progression curve if it exists

//						ArrayList<EditorPart> linkedConcordancesEditors = chartEditor.getLinkedEditors(ConcordanceEditor.class);

//						if(!linkedConcordancesEditors.isEmpty())	{

//							updateLinkedConcordanceEditor(linkedConcordancesEditors, selectedPointPositions);

//						}

//						

//						

//						// Get the linked edition editor and update it if exists

//						TXMBrowser linkedEditionEditor = (TXMBrowser)chartEditor.getLinkedEditor(TXMBrowser.class);

//						if(linkedEditionEditor != null)	{

//							updateLinkedEditionEditor(linkedEditionEditor, selectedPointPositions);

//						}

//						

//					}

//					else if(event.getID() == MouseEvent.MOUSE_CLICKED && mouseEvent.getClickCount() == 2 && eventArea == EventCallBack.AREA_EMPTY) {

//						// FIXME: debug

//						//System.err.println("ProgressionMouseClickedCallBack.processEvent(...).new Runnable() {...}.run(): double click in empty area");

//					}

//					else if(event.getID() == MouseEvent.MOUSE_CLICKED && mouseEvent.getClickCount() == 1 && eventArea == EventCallBack.AREA_EMPTY) {

//						// FIXME: debug

//						//System.err.println("ProgressionMouseClickedCallBack.processEvent(...).new Runnable() {...}.run(): single click in empty area");

//					}

//				}

//				// Key event

//				else if(event instanceof KeyEvent)	{

//					KeyEvent keyEvent = (KeyEvent)event;

//					

//					// return if zoom and pan modifier

//					if((keyEvent.getModifiers() & ZoomAndPanCallBack.keyboardZoomModifierKeyMask) != 0) {

//						return;

//					}

//					

//					// Arrow keys

//					if(keyEvent.getKeyCode() == KeyEvent.VK_LEFT || keyEvent.getKeyCode() == KeyEvent.VK_RIGHT)	{

//					

//						final ArrayList<Integer> selectedPointPositions = Utils.getChartCreator(chartEditor.getChartsEngine()).getSelectedPointPositions(chartEditor.getChart());

//	

//						// Get the linked concordance editors and update the one linked to the progression curve if it exists

//						ArrayList<EditorPart> linkedConcordancesEditors = chartEditor.getLinkedEditors(ConcordanceEditor.class);

//						if(!linkedConcordancesEditors.isEmpty())	{

//							updateLinkedConcordanceEditor(linkedConcordancesEditors, selectedPointPositions);

//						}

//						

//						// Get the linked edition editor and update it if exists

//						TXMBrowser linkedEditionEditor = (TXMBrowser)chartEditor.getLinkedEditor(TXMBrowser.class);

//						if(linkedEditionEditor != null)	{

//							updateLinkedEditionEditor(linkedEditionEditor, selectedPointPositions);

//						}

//					}

//				}

//			}

//		});

//

//	}

	//FIXME: version with new SynopticEditionEditor system edition

		// FIXME: Debug

		//System.err.println("ProgressionEventCallBack.updateLinkedConcordanceEditor(): linked editors count: " + linkedEditors.size());

			//FIXME: old color

			//RGBA lightred = new RGBA(249,208,208);

	//FIXME: version with TXMBroser old system edition

//	/**

//	 * Updates the linked edition editor.

//	 * If the editor doesn't exist it will be created.

//	 * @param editor

//	 */

//	public void updateLinkedEditionEditor(TXMBrowser linkedEditor, ArrayList<Integer> selectedPointPositions)	{

//		

//		try {

//			

//			// Unhighlight all tokens if no selected points

//			if(selectedPointPositions.size() < 1)	{

//				linkedEditor.setWordsIds(new ArrayList<String>(), new ArrayList<String>());

//				linkedEditor.showPage(linkedEditor.getCurrentPage());

//				return;

//			}

//			

//			Corpus corpus = ((Progression2) chartEditor.getResultData()).getCorpus();

//			StructuralUnit textS = corpus.getStructuralUnit("text"); //$NON-NLS-1$

//			Property textP = textS.getProperty("id"); //$NON-NLS-1$

//			Match selectedWordMatch = new Match(selectedPointPositions.get(selectedPointPositions.size() - 1), selectedPointPositions.get(selectedPointPositions.size() - 1));

//			String textId = selectedWordMatch.getValueForProperty(textP);

//

//			Text text = corpus.getText(textId);

//			if(text == null) {

//				Log.severe("Text " + textId + " is missing.");

//				return;

//			}

//

//			Edition edition = text.getEdition(corpus.getMainCorpus().getDefaultEdition());

//			if(edition == null) {

//				Log.severe("Default edition is missing.");

//				return;

//			}

//

//			// Get the current selected word to highlight more

//			List<String> selectedWordIds = selectedWordMatch.getValuesForProperty(corpus.getProperty("id")); //$NON-NLS-1$;

//

//			// Get all words to highlight from the progression chart data set

//			ArrayList<Integer> allPointPositions = ((ProgressionChartCreator)chartEditor.getEditorInput().getChartsEngine().getChartCreator(Progression2.class)).getAllPointPositions(chartEditor.getChart());

//			

//			ArrayList<String> wordIds = new ArrayList<String>(allPointPositions.size());

//			for(int i = 0; i < allPointPositions.size(); i++) {

//				Match match = new Match(allPointPositions.get(i), allPointPositions.get(i));

//				if(match.getValueForProperty(textP).equals(textId)) {

//					wordIds.add(match.getValueForProperty(corpus.getProperty("id"))); //$NON-NLS-1$;

//				}

//			}

//

//			Page openPage = edition.getPageForWordId(selectedWordIds.get(0));

//

//			if(openPage != null) {

//

//				// Create the linked editor if needed

//				if(linkedEditor == null || linkedEditor.isDisposed()) {

//					linkedEditor = OpenBrowser.openEdition(openPage.getFile().getAbsolutePath(), openPage.getFile().getName());

//					linkedEditor.setEdition(edition);

//					chartEditor.addLinkedEditor(linkedEditor);

//					

//					

//					int position = EModelService.BELOW;;

//					EditorPart parentEditor = chartEditor;

//					// Split vertically if there is already a concordance editor otherwise split horizontally

//					ConcordanceEditor linkedConcordanceEditor = (ConcordanceEditor)chartEditor.getLinkedEditor(ConcordanceEditor.class);

//					if(linkedConcordanceEditor != null)	{

//						position = EModelService.RIGHT_OF;

//						parentEditor = linkedConcordanceEditor;

//					}

//					

//					// Split and add linked editor

//					SWTEditorsUtils.addEditor(parentEditor, linkedEditor, position);

//				}

//

//				linkedEditor.showPage(openPage);

//				// Highlight tokens

//				linkedEditor.setWordsIds(wordIds, selectedWordIds);

//

//				IWorkbenchPage attachedPage = linkedEditor.getEditorSite().getPage();

//				attachedPage.activate(linkedEditor);

//			}

//		}

//		catch(Exception e) {

//			Log.printStackTrace(e);

//		}

//	}

		//FIXME: Debug

//

//		//this.chartComponent = (IChartComponent) panel;

//		// FIXME : transparency doesn't work with tool tips

//		// The problem here is that we normally need a JFrame but it seems to be impossible to embed a JFrame

////		this.setBackgroundMode(SWT.INHERIT_FORCE); // do not fix

////		ToolTipManager.sharedInstance().setLightWeightPopupEnabled(true); // do not fix

//

//		this.frame = SWT_AWT.new_Frame(this);

//		// Need to add an AWT Panel to fix mouse events and mouse cursors changes on Swing JPanel

//		//this.rootPanel = new Panel(new BorderLayout());

//		//this.rootPanel = new JRootPane();

//		this.rootPanel = new JPanel(new BorderLayout());

//		

//		

//		

//		this.frame.add(this.rootPanel);

//

//

//		

//		this.frame.setVisible(true);

////		this.frame.pack();

////		this.pack(true);

////		parent.pack();

////		this.layout(true);

////		parent.layout(true);

//		

//		// To fix MAC OS X + Java 1.7/1.8 SWT_AWT BUG

//		// see: https://bugs.eclipse.org/bugs/show_bug.cgi?id=418245#c12

////		SwingUtilities.invokeLater(new Runnable() {

////

////

////		   @Override

////		   public void run() {

//

//

//

//

////			// Need to add an AWT Panel to fix mouse events and mouse cursors changes on Swing JPanel

////			this.rootPanel = new Panel(new BorderLayout());

////			//rootPanel.add(this.getChartPanel()); // commenter cette ligne pour le test de scrolling ci-dessous

////			this.frame.add(this.rootPanel);

//

//

//			// FIXME: test, smarter way to embed the frame ? Actually it doesn't fix neither the tooltip transparency nor the cursor change on pan under Mac OS X

//	//		// Need to add an AWT Panel to fix mouse events and mouse cursors changes on Swing JPanel

//	//		Panel rootPanel = new Panel(new BorderLayout());

//	////		rootPanel.add(this.chartPanel); // commenter cette ligne pour le test de scrolling ci-dessous

//	//		frame.add(rootPanel);

//	//		JRootPane rootPane = new JRootPane();

//	//		rootPanel.add(rootPane);

//	//		rootPane.getContentPane().add(this.chartPanel);

//

//

//

//			// FIXME: tests with a JApplet as Rootpane rather than Panel

//	//		JApplet rootPanel = new JApplet();

//	//		rootPanel.add(this.chartPanel); // commenter cette ligne pour le test de scrolling ci-dessous

//	//		frame.add(rootPanel);

//

//

//

//

//			// FIXME : tests scroll Swing: les width des panel sont définies dans les méthodes de JFCChartsSwingComponentsProvider

//			// FIXME : ce code fait bugger le changement de couleur des barres au mouse over et la bordure colorée des tooltips

//			// FIXME : ce code augmente à fond la RAM consommée, il y a un prob de composants en double ?