Laboratoire ICAR » Plateforme TXM

//			chartEditor.forceFocus();

import org.txm.core.preferences.TXMPreferences;

import org.txm.core.results.TXMResult;

			if(ChartsEnginePreferences.getInstance().getString(ChartsEnginePreferences.DEFAULT_EXPORT_FORMAT).equals(SWTChartsComponentsProvider.getCurrent().getEditorSupportedExportFileFormats().get(i)))	{

import org.txm.core.preferences.TXMPreferences;

 * Exports chart editor view using chart editor export.

 * Exports the chart view as it drawn in the editor (cropped, panned, etc.).

		String extensions[] = new String[chartEditor.getSWTChartsComponentsProvider().getEditorSupportedExportFileFormats().size()];

		for(int i = 0; i < chartEditor.getSWTChartsComponentsProvider().getEditorSupportedExportFileFormats().size(); i++) {

			extensions[i] = "*." + chartEditor.getSWTChartsComponentsProvider().getEditorSupportedExportFileFormats().get(i); //$NON-NLS-1$

			if(ChartsEnginePreferences.getInstance().getString(ChartsEnginePreferences.DEFAULT_EXPORT_FORMAT).equals(chartEditor.getSWTChartsComponentsProvider().getEditorSupportedExportFileFormats().get(i)))	{

		// Select default chart export file format

			StatusLine.setMessage("Exporting view: " + file);

				System.err.println(NLS.bind(TXMUIMessages.exportColonCantCreateFileP0ColonP1, file, e1));

				System.err.println(NLS.bind(TXMUIMessages.impossibleToReadP0, file));

				System.err.println("Error: " + file + " is not a file"); //$NON-NLS-1$ //$NON-NLS-2$

			JobHandler jobhandler = new JobHandler(TXMUIMessages.exportingResults) {

						String outputFormat = chartEditor.getSWTChartsComponentsProvider().getEditorSupportedExportFileFormats().get(dialog.getFilterIndex());

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

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

import java.awt.AWTEvent;

import java.awt.Frame;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.awt.event.MouseMotionListener;

import javax.swing.JComponent;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.ui.IPartListener;

import org.eclipse.ui.IPartService;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PartInitException;

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

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

import org.txm.chartsengine.rcp.events.EventCallBack;

	static	{

		// FIXME: SJ: test to fix the Swing focus problems on the 3 OS

		IPartService service = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getPartService();

		service.addPartListener(new IPartListener() {

			@Override

			public void partOpened(IWorkbenchPart part) {

				// TODO Auto-generated method stub

			}

			@Override

			public void partDeactivated(IWorkbenchPart part) {

				if(part instanceof ChartEditor)	{

					((ChartEditor) part).onPartDeactivated();

				}

			}

			@Override

			public void partClosed(IWorkbenchPart part) {

				// TODO Auto-generated method stub

			}

			@Override

			public void partBroughtToTop(IWorkbenchPart part) {

				// TODO Auto-generated method stub

			}

			@Override

			public void partActivated(IWorkbenchPart part) {

				if(part instanceof ChartEditor)	{

					((ChartEditor) part).onPartActivated();

				}

			}

		});

	}

		// FIXME : see if we need to define the L&F as system for AWT/Swing components

	 * Creates a <code>ChartEditorInput</code> for the specified chart result.

	 * @param result

	 * @return a <code>ChartEditorInput</code>

	public ChartEditorInput createChartEditorInput(ChartResult result) {

		return new ChartEditorInput(this, result);

	}

	/**

	 * Creates a new chart component for the specified <code>ChartResult</code> save it in the specified <code>ChartEditorInput</code>.

	 * 

	 * @param chartsEngine

	 * @param chartEditorInput

	 * @param result

	 * @param preferencesNode

	 * @param chartType

	 * @return

	 */

	protected abstract boolean createChartComponent(ChartsEngine chartsEngine, ChartEditorInput chartEditorInput);

	/**

	 * Creates a new chart component for the specified <code>ChartResult</code> save it in the specified <code>ChartEditorInput</code>.

	 * 

	 * @param chartEditorInput

	 * @param result

	 * @param preferencesNode

	 * @param chartType

	 * @return

	 */

	public boolean createChartComponent(ChartEditorInput chartEditorInput)	{

		Log.finest(this.getClass().getSimpleName() + ": creating a chart component...");

		return this.createChartComponent(this.getChartsEngine(), chartEditorInput);

	}

	/**

	 * Creates and stores SWT charts components providers from installed extension contributions and define the current one according to the specified charts engine output format and provider supported input format.

	 */

				Log.fine("Starting SWT charts components provider: " + swtChartsComponentsProvider + ".");

	 * Gets an SWT charts component provider according to the specified charts engine output format and provider supported input format. 

	 * @return

	 * @return the installed charts components provider according to its class type if it exists otherwise null;

	 * Returns the export formats supported by the implementation of the <code>EditorPart</code> for the view.

	 * @return

	 */

	public abstract ArrayList<String> getEditorSupportedExportFileFormats();

	/**

	 * Export the current view of chart editor in the specified file.

	 * @param chartEditor

	 * @param file

	 * @param fileFormat

	 * @return

	 */

	public abstract File exportView(ChartEditor chartEditor, File file, String fileFormat);

	/**

	 * Opens the specified <code>ChartEditor</code> in the active page and registers the event listeners and context menus according to the type of the chart editor part.

	 * The ID of the editor and the chart type are the editor input result data class name.

	 * @param chartEditorInput

	 * @return

	 */

	public ChartEditor openEditor(ChartEditorInput chartEditorInput)	{

		return this.openEditor(chartEditorInput, chartEditorInput.getResult().getClass().getName());

	}

	/**

	 * Opens the <code>ChartEditor</code> specified by its id and ChartEditorInput in the active page and registers the event listeners and context menus according to the <code>EventCallBack</code> installed extensions. 

	 * @param chartEditorInput

	 * @param editorPartId

	 * @param chartType

	 * @return

	 */

	// FIXME: this method have some trouble when calling through a progress dialog

	// FIXME: this method is not in use anymore since the editor opening is now down in TXMEditor so the code for ChartEngine downgrading is not 

	// active anymore. Try to use again this code

	public ChartEditor openEditor(ChartEditorInput chartEditorInput, String editorPartId)	{

		ChartEditor openedChartEditorPart = null;

		IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();

		IWorkbenchPage page = window.getActivePage();

		boolean isAlreadyOpened = page.findEditors(chartEditorInput, editorPartId, IWorkbenchPage.MATCH_INPUT | IWorkbenchPage.MATCH_ID).length > 0;

		Log.finest("SWTChartsComponentsProvider.openEditor(): opening editor with id " + editorPartId);

		// if the editor is already open or the charts engine can create the specified chart type

		if(isAlreadyOpened || this.chartsEngine.canCreateChart(chartEditorInput.getResult()))	{

			//Log.finest(this.name + " - Opening editor for result data type " + chartEditorInput.getResultData().getClass() + " and editor id " + editorPartId);

			try {

				openedChartEditorPart = (ChartEditor) page.openEditor(chartEditorInput, editorPartId, true, IWorkbenchPage.MATCH_INPUT | IWorkbenchPage.MATCH_ID);

				openedChartEditorPart.setWasAlreadyOpened(isAlreadyOpened);

				// directly returns if the editor was already opened

				if(isAlreadyOpened)	{

					return openedChartEditorPart;

				}

			}

			catch(PartInitException e) {

				e.printStackTrace();

			}

		}

		// get the first installed charts engine that can create chart and use the SWT provider matching it

		else	{

			Log.warning("Rendering failed with current charts engine, trying to rendering chart with other installed SWT components provider and other charts engine:");

			boolean canCreate = false;

			for(int i = 0; i < ChartsEngine.getChartsEngines().size() && !canCreate; i++) {

				if(ChartsEngine.getChartsEngines().get(i) != this.chartsEngine)	{

					ChartsEngine chartsEngine = ChartsEngine.getChartsEngines().get(i);

					canCreate = chartsEngine.canCreateChart(chartEditorInput.getResult());

					// get a provider that can manage the charts engine

					if(canCreate)	{

						SWTChartsComponentsProvider provider = SWTChartsComponentsProvider.getComponentsProvider(chartsEngine);

						if(provider != null)	{

							provider.setChartsEngine(chartsEngine);

							chartEditorInput.setSWTChartsComponentsProvider(provider);

							Log.fine(provider.toString());

							return provider.openEditor(chartEditorInput, editorPartId);

						}

					}

				}

			}

		}

		return openedChartEditorPart;

	}

	/**

	 * 

	 * @param titleImage

	 * @param editorInputName

	 * @param result

	 * @param chartType

	 * @param params

	 * @return

	 */

	public ChartEditor openEditor(ChartResult result)	{

		return this.openEditor(this.createChartEditorInput(result), result.getClass().getName());

	}

//	/**

//	 * Initializes the default context menus.

//	 * @param composite

//	 */

//	public static void initDefaultContextMenus(ChartComposite composite)	{

//		if(composite != null)	{

//			composite.initItemAreaContextMenu();

//			composite.initEmptyAreaContextMenu();

//			composite.setCurrentContextMenu(EventCallBack.AREA_EMPTY);

//		}

//	}

	/**

			// FIXME: became useless?

		String str = this.name + " ("; //$NON-NLS-1$

		str += "supported input formats: " + this.supportedInputFormats.toString().replaceAll("\\[|\\]", ""); //$NON-NLS-1$ //$NON-NLS-2$

		str += ", Charts Engine: " + this.chartsEngine + ")"; //$NON-NLS-1$ //$NON-NLS-2$

		return str;

import org.txm.chartsengine.rcp.SWTChartsComponentsProvider;

	 * The linked SWT Charts Component Provider.

	 */

	protected SWTChartsComponentsProvider swtChartsComponentProvider;

	/**

	public EventCallBackHandler(SWTChartsComponentsProvider swtChartsComponentProvider, IChartComponent chartComponent) {

		this.swtChartsComponentProvider = swtChartsComponentProvider;

				Log.fine("Event call back handler warning: the event call back of type \"" + eventCallBack.getClass() + "\" has not been registered because one of same type is already registered."); //$NON-NLS-1$ //$NON-NLS-2$

		eventCallBack.setSwtChartsComponentProvider(this.swtChartsComponentProvider);

	 * The linked SWT Charts Component Provider.

	 */

	protected SWTChartsComponentsProvider swtChartsComponentProvider;

	/**

	/**

	 * @param swtChartsComponentProvider the swtChartsComponentProvider to set

	 */

	public void setSwtChartsComponentProvider(SWTChartsComponentsProvider swtChartsComponentProvider) {

		this.swtChartsComponentProvider = swtChartsComponentProvider;

	}

import org.txm.chartsengine.rcp.SWTChartsComponentsProvider;

	public ChartKeyListener(SWTChartsComponentsProvider swtChartsComponentProvider, IChartComponent chartComponent, double keyPressedPanFactor) {

		super(swtChartsComponentProvider, chartComponent);

	public AbstractChartMouseListener(SWTChartsComponentsProvider swtChartsComponentProvider, IChartComponent chartPanel) {

		super(swtChartsComponentProvider, chartPanel);

import javax.swing.JComponent;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.Platform;

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

import org.txm.chartsengine.rcp.events.EventCallBack;

import org.txm.chartsengine.rcp.events.EventCallBackHandler;

import org.txm.chartsengine.rcp.swt.SwingChartComposite;

	 * 

		this.chartComposite = SWTChartsComponentsProvider.getComponentsProvider(this.getResult().getChartsEngine()).createComposite(this, this.getResultArea());

		// FIXME: open dialog box message if the composite doesn't contain any chart (typically when the charts engine doesn't contain chart creator for the specified result data type)

//		if(composite.getChart() == null)	{

//			MessageDialog.openWarning(parent.getShell(), "Warning", "Current charts engine can not create chart for " + this.getResultData().getClass().getSimpleName() + " result type. You can set another charts engine in the preferences.");

//		}

		// FIXME: background color tests

		//this.composite.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_WHITE));

		//parent.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_WHITE));

//	/**

//	 * Initializes the default context menus.

//	 */

//	public void initDefaultContextMenus()	{

//		SWTChartsComponentsProvider.initDefaultContextMenus(this.chartComposite);

//	}

		if(this.getResult().getChartsEngine() != this.getSWTChartsComponentsProvider().getChartsEngine())	{

			Log.finest("ChartEditor.__updateEditorFromResult(): result charts engine  = " + this.getResult().getChartsEngine().getName() + " / Editor charts engine = " + this.getSWTChartsComponentsProvider().getChartsEngine().getName() + "."); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			this.getEditorInput().setSWTChartsComponentsProvider(SWTChartsComponentsProvider.getComponentsProvider(this.getResult().getChartsEngine()));

			this.getSWTChartsComponentsProvider().setChartsEngine(this.getResult().getChartsEngine());

		// if editor wasn't exist:

		// hiding command parameters, updating tool bar buttons states, registering context menus and event user callbacks 

		if(needInit

				//!update

//				&& !this.getResult().isChartDirty()

				)	{

//			getSite().getShell().getDisplay().syncExec(new Runnable() {

//				@Override

//				public void run() {

					// FIXME: decide if we automatically hide or not the parameter area

					//editor2.getTopToolbar().setComputingParametersVisible(false);

					// FIXME: tests to disable command if the chart is null and reenable it when the chart is computed 

					//editor2.getChartToolBar().synchronize();

					// initialize the default shared context menus as Export, etc.

					//this.initDefaultContextMenus();

					// registers user entries event call back extensions

//					this.registerEventCallBackExtensions();

					//FIXME: test to contribute to menu only in some context and also for key binding

					// create chart editor part context

//					this.activateContext();

//					IContextService contextService = (IContextService)getSite().getService(IContextService.class);

//					this.contextActivationToken = contextService.activateContext(CONTEXT_ID_CHART_EDITOR);

	//				// create chart composite context

	//				contextService.activateContext(this.chartComposite.getClass().getName());

					//FIXME: description test

					//editor2..setContentDescription("details");

					//editor2..setContentDescription(this.getResultData().getDetails());

					//this.initializeAWTDelegationListeners();

//				}

//			});

//		if(this.parentMultiPagesEditor == null)	{

//			//this.forceFocus();

//			this.activate();

//		}

	/**

	 * Activate the editor in the UI.

	 */

	//FIXME: this method doesn't work for Multi pages editor, eg. can not activating CAFactorialMapEditor stored in the CAEditor

	public void activate()	{

		// Activate the parent multi pages editor instead of this editor if it exists

		if(this.parentMultiPagesEditor != null)	{

			PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().activate(this.parentMultiPagesEditor);

		}

		else {

			// TODO: for focus and activation debug

//			System.out.println("ChartEditor.activate(): activating: " + this);

			//PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().bringToTop(this);

			//this.parent.setFocus();

//			if(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart() != this) {			

				//this.chartComposite.setFocus();

	//		}

			PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().activate(this);

			//getEditorSite().getPage().activate(this);

//			if(!this.chartComposite.hasFocus())	{

//				this.chartComposite.setFocus();

//			}

//			System.out.println("ChartEditor.activate(): new active editor = " + PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart());

		}

//		else	{

//			PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().bringToTop(this);

//		}

	}

//	/**

//	 * Forces the Composite to get the focus.

//	 */

//	public void forceFocus() {

//		// FIXME: debug

//		//System.err.println("ChartEditor.forceFocus()");

//

//		//this.chartComposite.setFocus();

//		//this.chartComposite.notifyListeners(SWT.FocusIn, null); // Needed to force the composite listener to handle the focus event

//	}

		//this.getEditorSite().getShell().setActive();

		// Debug

		Log.finest("ChartEditor.setFocus(): giving focus to chart composite..."); //$NON-NLS-1$

//	/**

//	 * Initialize Swing/AWT events delegation.

//	 * @param swingComponent

//	 */

//	protected void initializeAWTDelegationListeners()	{

//		try {

//			this.getChartComposite().getChartComponent().setChartEditor(this);

//			// FIXME: SJ: temporary fix. The composite may not be a SwingChartComposite

//			((SwingChartComposite) this.chartComposite).initializeAWTDelegationListeners();

//		}

//		catch (Exception e) {

//			Log.severe("ChartEditor.initializeAWTDelegationListeners(): can not initialize events delegation.");

//		}

//	}

	 * Returns the chart components provider associated with the editor (through its <code>ChartEditorInput</code>).

		return this.getEditorInput().getSWTChartsComponentsProvider();

	 * Gets the charts engine associated with the editor (through its <code>ChartEditorInput</code>).

		return this.getSWTChartsComponentsProvider().exportView(this, file, fileFormat);

	 * To check whether this editor was already opened when calling SWTChartsComponentsProvider.openEditor().

	 * To check whether this editor was already opened when calling SWTChartsComponentsProvider.openEditor().

//	@Override

//	public boolean isDirty() {

//		boolean d1 = super.isDirty();

//		boolean d2 = this.getResult().isChartDirty();

//		return super.isDirty() && this.getResult().isChartDirty();

//	}

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.ui.IPersistableElement;

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

import org.txm.chartsengine.rcp.SWTChartsComponentsProvider;

import org.txm.core.preferences.TXMPreferences;

	 * SWT chart components provider used to create the chart editor.

	 * Store it allows the switch of component provider in the RCP in keeping the chart editors in a coherent state.

	 */

	protected SWTChartsComponentsProvider swtChartsComponentsProvider = null;

	/**

	 * The chart component (for example : can be an AWT/Swing component as ChartPanel for JFC, etc.).

	 */

	protected Object chartComponent;

	/**

		this(SWTChartsComponentsProvider.getCurrent(), result);

	}

	/**

	 * Creates a chart editor input linked to the specified SWT charts components provider.

	 * @param swtComponentsProvider

	 * @param result

	 * @param preferencesNodeQualifier

	 */

	public ChartEditorInput(SWTChartsComponentsProvider swtComponentsProvider, ChartResult result) {

		this(swtComponentsProvider, result, null);

	}

	/**

	 * Creates a chart editor input linked to the specified SWT charts components provider.

	 * @param swtComponentsProvider

	 * @param name

	 * @param result

	 * @param preferencesNodeQualifier

	 * @param chartType

	 * @param chartContainer

	 */

	public ChartEditorInput(SWTChartsComponentsProvider swtComponentsProvider, ChartResult result, Object chartContainer) {

		this.swtChartsComponentsProvider = swtComponentsProvider;

		this.chartComponent = chartContainer;

	@Override

	public boolean exists() {

		// TODO Auto-generated method stub

		return false;

	}

	@Override

	public ImageDescriptor getImageDescriptor() {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	public IPersistableElement getPersistable() {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	public Object getAdapter(Class type) {

		// FIXME

//		System.err.println("************** ChartEditorInput.getAdapter() type = " + type + " / adaptable object = " + this);

//		 // if the object implements or extends the desired interface, use it

//		

//			  if (type.isInstance(IResource.class))

////		

//		    return this;

////		

////			 

////		

////			  // if the object is able to adapt itself, let it do it

////		

////			  if (this instanceof IAdaptable) {

////		

////			    IAdaptable adaptable = (IAdaptable) this;

////		

////			    Object adapter = adaptable.getAdapter(type);

////		

////			    if (adapter != null)

////		

////			      return adapter;

////		

////			  }

//		

//			 

//		

//			  // delegate to the global adapter manager

//		

//			  return Platform.getAdapterManager().getAdapter(this, type);

		return null;

	}

	 * Gets the <code>SWTChartsComponentsProvider</code> linked to this editor input.

	 * @return the swtComponentProvider

	 */

	public SWTChartsComponentsProvider getSWTChartsComponentsProvider() {

		return this.swtChartsComponentsProvider;

	}

	/**

	 * Gets the chart container (for example : can be an AWT/Swing component as ChartPanel for JFC, etc.).

	 * @return the chartContainer

	 */

	public Object getChartComponent() {

		return chartComponent;

	}

	/**

	 * Sets the chart component (for example: can be an AWT/Swing component as ChartPanel for JFC, etc.).

	 * @param chartComponent the chartContainer to set

	 */

	public void setChartComponent(Object chartComponent) {

		this.chartComponent = chartComponent;

	}

	/**

	 * Set the <code>SWTChartsComponentsProvider</code> to link to this editor input and to use for reading the chart object.

	 * @param swtChartsComponentsProvider the swtChartsComponentsProvider to set

	 */

	public void setSWTChartsComponentsProvider(SWTChartsComponentsProvider swtChartsComponentsProvider) {

		this.swtChartsComponentsProvider = swtChartsComponentsProvider;

	}

	/**

	/**

	 * Sets and updates the local preferences node qualifier from the result data.

	 * Synchronizes the local preferences node with the result data type, chart type, etc.

	 */

	// FIXME; should be move to TXMResultEditorInput class

	public void syncLocalPreferencesNode()	{

		//FIXME: to call when implemented in parent class

		//super.syncLocalPreferencesNode();

		// FIXME: persistence test

		if(this.getResult().getChartType() != null)	{

			TXMPreferences.putLocal(this.result, ChartsEnginePreferences.CHART_TYPE, this.getResult().getChartType());

		}

	}

 * A component dedicated to render chart, from a file, from an AWT object, etc. and to be embedded in a SWT ChartComposite.

//	/**

//	 * Sets the square off unit axis constraints state.

//	 * @param enabled

//	 */

//	public void setSquareOffEnabled(boolean enabled);

	/**

	 * Loads the chart from specified data.

	 * @param data

	 */

	public abstract void loadChart(Object data);

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

	 */

	public abstract void loadChart();

	/**

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

	 * @param resetView

	 * @param clearChartItemsSelection

	 * @param squareOff

	 */

	public void loadChart(boolean resetView, boolean clearChartItemsSelection, boolean squareOff)	{

		this.loadChart();

		if(squareOff)	{

			this.squareOff();

		}

		if(clearChartItemsSelection)	{

			this.clearChartItemsSelection();

		}