Laboratoire ICAR » Plateforme TXM

 *

 */

public class ChartsEnginePreferencePage extends TXMPreferencePage {

	/**

	 * The charts engine selection combo box.

	 */

	private ComboFieldEditor chartsEngineSelectionComboField;

	/**

	 * The charts engine export formats selection combo box.

	 */

	private ComboFieldEditor chartsEngineExportFormatsComboField;

	protected boolean charsEngineHasChanged = false;

	@Override

	protected void createFieldEditors() {

		// Charts engine selection

		String chartsEngines[][] = new String[ChartsEnginesManager.getInstance().size()][2];

		// FIXME: SJ: test to select the chart engine order rather than a exclusive one since the engines are not exclusive anymore, eg. some to create charts and other to create graphs

		// current engine supported export formats

		// other shared preferences

		SWTChartsComponentsProvider.createChartsRenderingPreferencesFields(this, this.getFieldEditorParent());

		FontFieldEditor font = new FontFieldEditor(ChartsEnginePreferences.FONT, "Font", "Specificities / Spécificités / Специфичность", this.getFieldEditorParent()); //$NON-NLS-1$ //$NON-NLS-2$

		this.addField(font);

		// FIXME: preview area tests

	}

	 * 

	 * @param engine

	 */

		this.addField(this.chartsEngineExportFormatsComboField);

	}

	@Override

	public void propertyChange(PropertyChangeEvent event) {

		super.propertyChange(event);

		// FIXME: SJ: test to try to update the Export formats combo box when changing of current charts engine

		// NOTE: SJ: warning, event.getProperty() seems bugged and does not return the correct property name but the string "field_value_editor"

			this.charsEngineHasChanged = true;

		}

	}

	@Override

	public void init(IWorkbench workbench) {

		this.setPreferenceStore(new TXMPreferenceStore(ChartsEnginePreferences.getInstance().getPreferencesNodeQualifier()));

		this.setDescription(ChartsUIMessages.thesePreferencesWillApplyToNewChartsPreviouslyCreatedChartsWillNotBeAffected);

	}

	@Override

	public boolean performOk() {

		super.performOk();

		// Set the new monochrome color for all charts engine theme

		}

		Log.info(ChartsUIMessages.recreatingChartsEngineAndSWTChartComponentsProvider);

		ChartsEnginesManager.getInstance().setCurrentEngine(this.getPreferenceStore().getString(ChartsEnginePreferences.CURRENT_NAME));

		// Sets the new current charts SWT component provider according to the new current charts engine

		SWTChartsComponentsProvider.setCurrrentComponentsProvider(ChartsEnginesManager.getInstance().getCurrentEngine());

		// Reset the default export format to the new current charts engine first supported export file format

		return true;

	}

		}

		// Chart composite

		GridData gd = new GridData(GridData.FILL_BOTH);

		this.chartComposite.setLayoutData(gd);

 *

 */

public interface IChartComponent {

	/**

	 * Zooms the view at x and y coordinates.

	 * @param x

	 * @param y

	 * @param zoomIn

	 */

	public abstract void zoom(double x, double y, boolean zoomIn);

	/**

	 * Resets the view.

	 */

	/**

	 * Pans the view.

	 * @param srcX

	 * @param srcY

	 * @param dstX

	/**

	 * Gets the linked editor.

	 * @return

	 */

	public ChartEditor getChartEditor();

	/**

	 * Sets the linked editor.

	 * @param editor

	 */

	public void setChartEditor(ChartEditor editor);

	/**

	 * Updates the mouse over item selection according to the specified mouse event.

	 * @param event

	 */

	public void updateMouseOverItem(MouseEvent event);

	/**

	 * Checks if the component has the focus.

	 * @return

	 */

	public boolean hasFocus();

	/**

	 */

	public void squareOff();

import org.txm.Toolbox;

import org.txm.chartsengine.core.ChartCreator;

import org.txm.chartsengine.core.ChartsEngine;

import org.txm.chartsengine.core.preferences.ChartsEnginePreferences;

import org.txm.chartsengine.core.results.ChartResult;

import org.txm.chartsengine.rcp.editors.ChartEditor;

			ArrayList<String> chartsEngineNames = new ArrayList<>();

			ArrayList<ChartCreator> allChartCreators = new ArrayList<>();

				}

			}

import org.txm.utils.logger.Log;

/**

 * 

 * @author sjacquot

 *

 */

public abstract class ChartComposite extends Composite {

	/**

	 * Custom tool tip.

	 */

	// FIXME: tests HTML tool tips

	protected ___CustomHTMLToolTip toolTip;

	/**

	 * The chart component.

	 */

	protected IChartComponent chartComponent;

	/**

	 * Context menus.

	 */

	 */

	public ChartComposite(ChartEditor<ChartResult> chartEditor, Composite parent, int style) {

		super(parent, style);

		this.chartEditor = chartEditor;

		this.contextMenus.add(null);

		this.contextMenus.add(null);

	}

	/**

	 * Loads the chart from specified data object (can be a File, an UI component, etc.).

	 * 

	 * @param chart

	 */

	public abstract void loadChart(Object chart);

	/**

	 * Loads or reloads the chart from the chart object stored in the linked editor input.

	 * This method is especially used for file based implementations of charts engine for reloading a file that has been externally modified.

	/**

	 * Loads or reloads the chart from the chart object stored in the linked editor input.

	 * @param resetView

	 * @param clearChartItemsSelection

	 * @param squareOff

	 */

		this.loadChart();

			this.squareOff();

		}

			this.clearChartItemsSelection();

		}

			this.resetView();

		}

	}

	/**

	 * Loads or reloads the chart from the chart object stored in the linked editor input.

	 * @param resetView

	 * @param clearChartItemsSelection

	 */

		this.loadChart(resetView, clearChartItemsSelection, false);

	}

	/**

	 * Creates a new chart component.

	 * @param chartsEngine

	 * @param chartEditorInput

	 * @return

	 * @param chartEditorInput

	 * @return

	 */

	}

	/**

	/**

	 * Creates the pop up menu dedicated to empty area location click event that is populated from plugin.xml.

	 */

		Menu menu = TXMEditor.initContextMenu(this, CONTEXT_MENU_EMPTY_AREA_ID);

	}

	/**

	 * Creates the pop up menu dedicated to chart item location click event.

	 */

		Menu menu = TXMEditor.initContextMenu(this, CONTEXT_MENU_ITEM_AREA_ID);

	}

	/**

	 * Defines the current context menu to display on menu event.

	 * @param index

	 */

		// Debug

		Log.finest("ChartComposite.setCurrentContextMenu(): setting menu to " + index + " / " + this.contextMenus.get(index)); //$NON-NLS-1$

		this.setMenu(this.contextMenus.get(index));

	}

	/**

	 * Gets the menu specified by its index.

	 * @param index

	 * @return

	 */

		return this.contextMenus.get(index);

	}

	/**

	 * Resets the chart view (zoom, pan, rotation).

	 */

			this.chartComponent.resetView();

				this.chartComponent.squareOff();

			}

		}

	 * Copies the chart view as image in the clipboard from the specified chart component.

	 */

	public abstract void copyChartViewToClipboard();

	/**

	 * Exports the current view of the composite in the specified file.

	 * 

	/**

	 * Gets the chart object.

	 * @return

	 */

		return this.getChartResult().getChart();

	};

	/**

	 * Gets the linked result.

	 * @return

	 */

		return this.chartEditor.getResult();

	}

	/**

	 * Gets the charts engine of the linked result.

	 * @return

	 */

		return this.getChartResult().getChartsEngine();

	}

	/**

	 * Zooms the chart view at x and y coordinates.

	 * @param x

	 * @param y

	 * @param zoomIn

	 */

		this.chartComponent.zoom(x, y, zoomIn);

	}

	/**

	 * Pans the chart view.

	 * @param chartComponent

	 * @param srcX

	 * @param srcY

	 * @param dstY

	 * @param panFactor

	 */

		this.chartComponent.pan(srcX, srcY, dstX, dstY, panFactor);

	}

	/**

	 */

			this.chartComponent.squareOff();

		}

	}

	/**

	 * Checks if the composite AND the chart component have the focus.

	 * @return

	 */

		return this.chartComponent.hasFocus() && this.isFocusControl();

	}

	/**

	 * Gets the mouse call back handler registered for the chart component.

	 * @return

	 */

	public abstract EventCallBackHandler getMouseCallBackHandler();

	/**

	 * Gets the key call back handler registered for the chart component.

	 * @return

	 */

	public abstract EventCallBackHandler getKeyCallBackHandler();

	/**

	 * Gets the mouse call back handler registered for the specified component.

	 * @param component

	 * @return

	 */

	public EventCallBackHandler getMouseCallBackHandler(Component component) {

		EventCallBackHandler handler = null;

		EventListener[] listeners = component.getMouseListeners();

				handler = (EventCallBackHandler) listeners[i];

				break;

			}

		}

		return handler;

	}

	/**

	 * Gets the key call back handler registered for the specified component.

	 * @param component

	 * @return

	 */

	public EventCallBackHandler getKeyCallBackHandler(Component component) {

		EventCallBackHandler handler = null;

		EventListener[] listeners = component.getKeyListeners();

				handler = (EventCallBackHandler) listeners[i];

				break;

			}

		}

		return handler;

	}

	/**

	 * Gets the event call back handler of the specified class.

	 * @param listenerType

	 * @return

	 */

		EventCallBackHandler handler = null;

		EventListener[] listeners = ((Component) this.chartComponent).getListeners(listenerType);

				handler = (EventCallBackHandler) listeners[i];

				break;

			}

		}

		return handler;

	}

	/**

	 * Initializes the default context menus.

	 * @param composite

	 */

		this.initItemAreaContextMenu();

		this.initEmptyAreaContextMenu();

		this.setCurrentContextMenu(EventCallBack.AREA_EMPTY);

	}

	/**

	 * Registers user entries event call back extensions.

	 */

		ChartResult result = this.chartEditor.getResult();

		String extensionPointId = "org.txm.chartsengine.eventcallback"; //$NON-NLS-1$

		IConfigurationElement[] contributions = Platform.getExtensionRegistry().getConfigurationElementsFor(extensionPointId);

				try {

					eventCallBack.setChartEditor(this.chartEditor);

					EventCallBackHandler mouseHandler = this.getMouseCallBackHandler();

						Log.fine("ChartEditor.registerEventCallBackExtensions(): call back of type " + eventCallBack.getClass()  //$NON-NLS-1$

								+ " registered in mouse handler (chart editor = " + this.chartEditor.getClass()  //$NON-NLS-1$

								+ ", result data class = " + result.getClass()  //$NON-NLS-1$

						mouseHandler.registerEventCallBack(eventCallBack);

					}

					EventCallBackHandler keyboardHandler = this.getKeyCallBackHandler();

						Log.fine("ChartEditor.registerEventCallBackExtensions(): call back of type " + eventCallBack.getClass()  //$NON-NLS-1$

								+ " registered in key handler (chart editor = " + this.chartEditor.getClass()  //$NON-NLS-1$

						keyboardHandler.registerEventCallBack(eventCallBack);

					}

				}

					e.printStackTrace();

				}

				break;

	/**

	 * Gets the chart component dedicated to rendering the chart.

	 * @return the chartComponent

	 */

	public IChartComponent getChartComponent() {

 */

// FIXME: SJ: this class should not used the SWTChartsComponentsProvider but directly the current charts engine

public class ExportChart extends BaseAbstractHandler {

	private static final String ID = "ExportChart"; //$NON-NLS-1$

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		Object selection = this.getCorporaViewSelectedObject(event);

			return null;

		}

		final ChartResult chartResult = (ChartResult) selection;

		Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();

		final FileDialog dialog = new FileDialog(shell, SWT.SAVE);

		// Create the extensions from the current charts engine supported file formats

		String extensions[] = new String[SWTChartsComponentsProvider.getCurrent().getChartsEngineSupportedExportFileFormats().size()];

		int defaultChartFormatIndex = 0;

		for (int i = 0; i < SWTChartsComponentsProvider.getCurrent().getChartsEngineSupportedExportFileFormats().size(); i++) {

			extensions[i] = "*." + SWTChartsComponentsProvider.getCurrent().getChartsEngineSupportedExportFileFormats().get(i); //$NON-NLS-1$

			// Store the default chart export file format index

				defaultChartFormatIndex = i;

			}

		}

		dialog.setFilterExtensions(extensions);

		// Select default chart export file format

		dialog.setFilterIndex(defaultChartFormatIndex);

		dialog.setOverwrite(true);

		if (LastOpened.getFile(ID) != null) {

			dialog.setFilterPath(LastOpened.getFolder(ID));

		}

		dialog.setFileName(chartResult.getValidFileName());

		if (dialog.open() != null) {

			StatusLine.setMessage("Exporting chart...");

			String filepath = dialog.getFilterPath() + "/" + dialog.getFileName(); //$NON-NLS-1$

			final File file = new File(filepath);

			LastOpened.set(ID, file.getParent(), file.getName());

			try {

				file.createNewFile();

				Log.severe(NLS.bind(TXMUIMessages.exportColonCantCreateFileP0ColonP1, file, e1));

			}

			if (!file.canWrite()) {

			if (!file.isFile()) {

				Log.severe("Error: " + file + " is not a file"); //$NON-NLS-1$ //$NON-NLS-2$

			}

			JobHandler jobhandler = new JobHandler(TXMUIMessages.exportingResults) {

				@Override

				protected IStatus run(IProgressMonitor monitor) {

					try {

						this.runInit(monitor);

						monitor.beginTask(TXMUIMessages.exporting, 100);

						// compute the result if needed

							chartResult.compute(monitor);

						}

						String outputFormat = SWTChartsComponentsProvider.getCurrent().getChartsEngineSupportedExportFileFormats().get(dialog.getFilterIndex());

						if (file.exists()) {

							Log.info(NLS.bind(TXMUIMessages.p1ExportSavedInFileColonP0, file.getAbsolutePath(), outputFormat.toUpperCase()));

							// Open internal editor in the UI thread

								this.syncExec(new Runnable() {

									@Override

									public void run() {

										OpenGraph.OpenFile(file.getAbsolutePath());

									}

								});

							}

							System.out.println(NLS.bind(TXMUIMessages.failedToExportInFileP0WithFormatP1, file.getAbsolutePath(), outputFormat));

						}

						return Status.CANCEL_STATUS;

						org.txm.utils.logger.Log.printStackTrace(e);

						return Status.CANCEL_STATUS;

						monitor.done();

						JobsTimer.stopAndPrint();

					}

					return Status.OK_STATUS;

				}

			};

			jobhandler.startJob();

		}

		return null;

	}

import org.txm.rcp.swt.widget.ThresholdsGroup;

import org.txm.rcp.swt.widget.structures.PropertiesComboViewer;

import org.txm.searchengine.cqp.corpus.CQPCorpus;

import org.txm.searchengine.cqp.corpus.Subcorpus;

import org.txm.specificities.core.functions.Specificities;

import org.txm.specificities.core.preferences.SpecificitiesPreferences;

				this.fMaxSpinner = thresholdsGroup.getFMaxSpinner();

				this.vMaxSpinner = thresholdsGroup.getVMaxSpinner();

				this.vMaxSpinner.setMinimum(2);

			}

		}

import org.txm.chartsengine.jfreechart.core.themes.base.JFCTheme;

import org.txm.chartsengine.jfreechart.core.themes.base.SymbolAxisBetweenTicks;

import org.txm.chartsengine.jfreechart.core.themes.highcharts.defaulttheme.HighchartsDefaultTheme;

import com.lowagie.text.Document;

import com.lowagie.text.Rectangle;

		return jfcTheme;

	}

	@Override

	}

	@Override

	public File exportChart(Object chart, File file, String outputFormat, int imageWidth, int imageHeight, int drawingAreaX, int drawingAreaY, int drawingAreaWidth, int drawingAreaHeight) {

		return JFCChartsEngine.export(chart, file, outputFormat, imageWidth, imageHeight, drawingAreaX, drawingAreaY, drawingAreaWidth, drawingAreaHeight);

	public static File exportRasterImage(JFreeChart chart, File file, String outputFormat, int imageWidth, int imageHeight, int drawingAreaX, int drawingAreaY, int drawingAreaWidth,

			int drawingAreaHeight) {

		// Crop

		bufferedImage = bufferedImage.getSubimage(drawingAreaX, drawingAreaY, drawingAreaWidth, drawingAreaHeight);

	@Override

	public ArrayList<String> getSupportedOutputDisplayFormats() {

		formats.add(OUTPUT_FORMAT_JFC_JAVA2D);

	@Override

	public ArrayList<String> getSupportedOutputFileFormats() {

		formats.add(OUTPUT_FORMAT_SVG); // Default format

package org.txm.chartsengine.jfreechart.core;

import java.awt.Color;

import java.util.ArrayList;

import org.jfree.chart.JFreeChart;

import org.jfree.chart.plot.CategoryPlot;

import org.jfree.chart.plot.XYPlot;

import org.txm.chartsengine.core.ChartCreator;

import org.txm.chartsengine.core.preferences.ChartsEnginePreferences;

import org.txm.chartsengine.core.results.ChartResult;

import org.txm.chartsengine.jfreechart.core.renderers.interfaces.IRendererWithItemSelection;

/**

 * JFreeChart base chart creator.

 * 

 * @author sjacquot

 *

 */

	@Override

		this.updateChart(result, true);

	}

	/**

	 * Updates the chart according to the shared parameters, also applies the current theme to the chart and the user renderer settings.

	 * 

	 * @param result

	 * @param applyTheme

	 */

		// Java object

		if (result.getChart() instanceof JFreeChart) {

			chart.setNotify(true);

		}

		}

	}

		return colors;

	}

	@Override

		return JFCChartsEngine.class;

	}

}

import java.io.File;

import org.txm.ahc.core.functions.AHC;

import org.txm.chartsengine.r.core.RChartCreator;

/**

 * @author sjacquot

 *

 */

	@Override

		String cmd = null;

		// 2D

	@Override

		return AHC.class;

	}

}

 */

// FIXME: simulation tests for cooccurrence chart

public class CooccurrenceGSChartCreator extends GSChartCreator {

	/**

	 * 

	 */

	public CooccurrenceGSChartCreator() {

		// TODO Auto-generated constructor stub

	}

	@Override

	public Object createChart(ChartResult result) {

		Cooccurrence cooccurrence = (Cooccurrence) result.getParent();

		Graph graph = new SingleGraph(cooccurrence.getSimpleName());