Laboratoire ICAR » Plateforme TXM

package org.txm.chartsengine.rcp.editors;

import java.io.File;

import java.util.ArrayList;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.layout.FormAttachment;

import org.eclipse.swt.layout.FormData;

import org.eclipse.swt.layout.FormLayout;

import org.eclipse.swt.layout.RowLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Group;

import org.eclipse.swt.widgets.ToolItem;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.IPartListener;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.part.EditorPart;

import org.eclipse.ui.part.MultiPageEditorPart;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.txm.chartsengine.rcp.SWTChartsComponentsProvider;

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

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

import org.txm.functions.TXMResult;

import org.txm.rcp.editors.TXMEditorPart;

import org.txm.rcpapplication.Application;

/**

 * Base class of all charts SWT <code>EditorPart</code> subclasses.

 * @author sjacquot

 *

 */

public class ChartEditorPart extends TXMEditorPart {

	/**

	 * The <code>EditorPart</code> ID constant. 

	 */

	protected static final String ID =  ChartEditorPart.class.getCanonicalName();

	/**

	 * The tool bar.

	 */

	protected ChartEditorToolBar toolBar;

	protected Composite parametersComposite;

	protected Group parametersGroup;

	/**

	 * The chart drawing area composite.

	 */

	protected ChartComposite chartComposite;

	protected boolean wasAlreadyOpened;

	/**

	 * The multi pages editor which contains this editor if exists.

	 */

	protected MultiPageEditorPart parentMultiPagesEditor = null;

	/**

	 * Linked editors.

	 */

	protected ArrayList<EditorPart> linkedEditors = null;

	/**

	 *

	 */

	public ChartEditorPart()	{

		super();

	}

	/**

	 * 

	 * @param swtComponentsProvider

	 * @param editorInputName

	 * @param titleImage

	 * @param resultData

	 * @param chartContainer

	 */

	public ChartEditorPart(SWTChartsComponentsProvider swtComponentsProvider, String editorInputName, TXMResult resultData, String preferencesNodeQualifier, String chartType, Object chartContainer) {

		this(swtComponentsProvider, new ChartEditorInput(swtComponentsProvider, editorInputName, resultData, preferencesNodeQualifier, chartType, chartContainer));

	}

	/**

	 * 

	 * @param swtComponentsProvider

	 * @param chartEditorInput

	 */

	public ChartEditorPart(SWTChartsComponentsProvider swtComponentsProvider, ChartEditorInput chartEditorInput) {

		this.setInput(chartEditorInput);

		this.setPartName(chartEditorInput.getName());

		this.wasAlreadyOpened = false;

	}

//	/**

//	 * Gets the <code>EditorPart</code> ID.

//	 * @return the ID

//	 */

//	public abstract String getID();

	/**

	 * Gets the <code>EditorPart</code> ID.

	 * @return the ID

	 */

	public String getID()	{

		return ID;

	}

	@Override

	public void init(IEditorSite site, IEditorInput input) throws PartInitException {

		this.setSite(site);

		this.setInput(input);

		// FIXME: see how to use the Adapters and AdapterFactory to define image and title of Editor in the contributing plug-ins

		// another way is to use editors extension in plug-ins and redefine icon and name, using this solution the problem is that the name (which is also editor title) can not be dynamic according to the result data

		// so it seems better to use Adapters if that's possible

		this.setPartName(input.getName());

	}

	@Override

	public void createPartControl(Composite parent) {

		super.createPartControl(parent);

		// Test, original code

		FormLayout mainLayout = new FormLayout();

//		mainLayout.marginHeight = 5;

//		mainLayout.marginWidth = 5;

		mainLayout.marginTop = 3;

		mainLayout.marginLeft = 0;

		mainLayout.spacing = 3;

		parent.setLayout(mainLayout);

//		parent.setLayout(new RowLayout(SWT.VERTICAL));

//		parent.setLayoutData(new RowData(50, 40));

		// Toolbar

		// FIXME: tests

		//this.toolBar = new ChartEditorToolBar(parent, SWT.FLAT | SWT.SHADOW_OUT, this);

		this.toolBar = new ChartEditorToolBar(parent, SWT.FLAT, this);

		// FIXME: dimensions/margin tests

//		this.toolBar.computeSize(1500, 800, true);

//		this.toolBar.setBounds(200, 400, 1500, 300);

//		this.toolBar.pack();

//		this.toolBar.setSize(1500, 800);

		// FIXME: command parameters composite

		this.parametersComposite = new Composite(parent, SWT.NONE);

		// FIXME: group tests

		this.parametersGroup = new Group(this.parametersComposite, SWT.NONE);

		this.parametersGroup.setText("Command parameters");

		RowLayout layout1 = new RowLayout();

		layout1.marginLeft = 10;

		layout1.marginTop = 10;

		layout1.spacing = 8;

		layout1.wrap = true;

		layout1.center = true;

		this.parametersGroup.setLayout(layout1);

		FormData formData = new FormData();

		formData.top = new FormAttachment(this.toolBar);

		//formData.bottom = new FormAttachment(100);

		formData.left = new FormAttachment(0);

		formData.right = new FormAttachment(100);

		formData.height = 0;

		this.parametersComposite.setLayoutData(formData);

		//this.parametersComposite.setBackground(new Color (Display.getCurrent(), 255, 0, 0));

		RowLayout layout = new RowLayout();

		layout.marginLeft = 10;

		layout.marginTop = 10;

		layout.spacing = 8;

		layout.wrap = true;

		layout.center = true;

		this.parametersComposite.setLayout(layout);

		//this.parametersGroup.setLayout(layout);

		this.parametersComposite.setVisible(false);

		this.parametersComposite.getParent().layout(true);

		// FIXME: tests show/hide parameters

		final ToolItem showParameters = new ToolItem(this.toolBar, SWT.CHECK);

		showParameters.setImage(AbstractUIPlugin.imageDescriptorFromPlugin(Application.PLUGIN_ID, "platform:/plugin/org.txm.rcp/icons/add.png").createImage());

		showParameters.setToolTipText("Show/Hide command parameters");

		showParameters.setSelection(false);

		showParameters.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				parametersComposite.pack();

				int height = 0; 

				if(showParameters.getSelection())	{

					height = parametersComposite.getSize().y;

				}

				((FormData)parametersComposite.getLayoutData()).height = height;

				parametersComposite.getParent().layout(true);

				parametersComposite.setVisible(showParameters.getSelection());

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) {

				// TODO Auto-generated method stub

			}

		});

		// FIXME: background color tests

		//this.toolBar.setBackground(parent.getBackground());

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

		// Chart composite

		ChartComposite composite = this.getEditorInput().getSWTChartsComponentsProvider().createComposite(this, parent);

//		FormData formData2 = new FormData();

//		formData2.top = new FormAttachment(toolBarsComposite, 10);

//		composite.setLayoutData(formData2);

		// 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));

	}

	/**

	 * Activate the editor in the UI.

	 */

	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	{

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

		}

	}

	/**

	 * Forces the Composite to get the focus.

	 */

	public void forceFocus()	{

		// FIXME: debug

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

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

	}

	@Override

	public void setFocus() {

		// FIXME: debug

		//System.err.println("ChartEditorPart.setFocus()");

		this.chartComposite.setFocus();

	}

	@Override

	public boolean isDirty() {

		return false;

	}

	@Override

	public boolean isSaveAsAllowed() {

		return false;

	}

	@Override

	public void doSave(IProgressMonitor monitor) {

		// TODO Auto-generated method stub

	}

	@Override

	public void doSaveAs() {

		// TODO Auto-generated method stub

	}

	/**

	 * Gets the editor input.

	 * @return the editorInput

	 */

	public ChartEditorInput getEditorInput() {

		return (ChartEditorInput) super.getEditorInput();

	}

	/**

	 * Gets the chart drawing area composite.

	 * @return the composite

	 */

	public ChartComposite getComposite() {

		return this.chartComposite;

	}

	/**

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

	 */

	public void resetView() {

		this.chartComposite.resetView();

	}

	/**

	 * Zooms the chart view at x and y coordinates.

	 * @param x

	 * @param y

	 * @param zoomIn

	 */

	public void zoom(double x, double y, boolean zoomIn)	{

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

	}

	/**

	 * Pans the chart view.

	 * @param chartComponent

	 * @param srcX

	 * @param srcY

	 * @param dstX

	 * @param dstY

	 * @param panFactor

	 */

	public void pan(double srcX, double srcY, double dstX, double dstY, double panFactor)	{

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

	}

	/**

	 * Copy the current chart view to clipboard.

	 */

	public void copyChartViewToClipboard()	{

		this.getEditorInput().getSWTChartsComponentsProvider().copyChartToClipboard(this.getComposite().getChartComponent());

	}

	/**

	 * Loads the chart from the chart object stored into the composite.

	 */

	public void loadChart()	{

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

			@Override

			public void run() {

				chartComposite.reloadChart();

			}

		});

	}

	/**

	 * Updates the specified chart stored in the editor and according to the stored TXM result.

	 * @return

	 */

	public boolean updateChart()	{

		return this.getSWTChartsComponentsProvider().updateChart(this);

	}

	/**

	 * Creates a new chart for the specified result data and save it in the current editor input.

	 * @param resultData

	 * @param preferencesNode

	 */

	public void createChart(TXMResult resultData, String preferencesNode)	{

		this.getSWTChartsComponentsProvider().createChart(this.getEditorInput(), resultData, preferencesNode);

	}

	/**

	 * Creates a new chart for current stored result and save it in the current editor input.

	 */

	public void createChart()	{

		this.createChart(this.getResultData(), this.getPreferencesNodeQualifier());

	}

	/**

	 * Disposes the editor.

	 * Implementations using a Composite to embed AWT/Swing components should manually call this.composite.dispose() in the redefined method.

	 */

	public void dispose()	{

		this.chartComposite.dispose();

		super.dispose();

	}

	/**

	 * Returns the preferences node qualifier linked to the chart of this editor.

	 * @return

	 */

	public String getPreferencesNodeQualifier() {

		return this.getEditorInput().getPreferencesNodeQualifier();

	}

	/**

	 * Closes the editor from the UI thread.

	 */

	public void close()	{

		final EditorPart self = this;

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

			@Override

			public void run() {

				getSite().getPage().closeEditor(self, false);

			}

		});

	}

	/**

	 * Returns the tool bar of this editor.

	 * @return the toolBar

	 */

	public ChartEditorToolBar getToolBar() {

		return toolBar;

	}

	/**

	 * Returns the result object associated with the editor.

	 * @return

	 */

	public TXMResult getResultData()	{

		return this.getEditorInput().getResultData();

	}

	/**

	 * 

	 * @return

	 */

	public String getChartType()	{

		return this.getEditorInput().getChartType();

	}

	/**

	 * Returns the chart associated with the editor.

	 * @return

	 */

	public Object getChart()	{

		return this.chartComposite.getChart();

	}

	/**

	 * Returns the chart components provider associated with the editor.

	 * @return

	 */

	public SWTChartsComponentsProvider getSWTChartsComponentsProvider()	{

		return this.getEditorInput().getSWTChartsComponentsProvider();

	}

	/**

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

	 * @param file

	 * @param fileFormat

	 * @return

	 */

	public File exportView(File file, String fileFormat)	{

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

	}

	/**

	 * Gets the parent multipages editor part if exists.

	 * @return the parentMultiPagesEditor

	 */

	public MultiPageEditorPart getParentMultiPagesEditor() {

		return parentMultiPagesEditor;

	}

	/**

	 * Sets the specified multipages editor part as parent of this one.

	 * @param parentMultiPagesEditor the parentMultiPagesEditor to set

	 */

	public void setParentMultiPagesEditor(MultiPageEditorPart parentMultiPagesEditor) {

		this.parentMultiPagesEditor = parentMultiPagesEditor;

	}

	/**

	 * Links the specified editor to this editor.

	 * @param editor

	 */

	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("ChartEditorPart.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

	 */

	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

	 */

	public ArrayList<EditorPart> getLinkedEditors()	{

		return this.linkedEditors;

	}

	/**

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

	 * @param editorClass

	 * @return

	 */

	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

	 */

	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;

//	}

	/**

	 * @param composite the composite to set

	 */

	public void setComposite(ChartComposite composite) {

		this.chartComposite = composite;

	}

	/**

	 * @return the parametersComposite

	 */

	public Composite getParametersComposite() {

		return parametersComposite;

	}

	/**

	 * @return the wasAlreadyOpened

	 */

	public boolean wasAlreadyOpened() {

		return wasAlreadyOpened;

	}

	/**

	 * @param wasAlreadyOpened the wasAlreadyOpened to set

	 */

	public void setWasAlreadyOpened(boolean wasAlreadyOpened) {

		this.wasAlreadyOpened = wasAlreadyOpened;

	}

	/**

	 * @return the parametersGroup

	 */

	public Group getParametersGroup() {

		return parametersGroup;

	}

}

package org.txm.chartsengine.rcp.editors;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IPersistableElement;

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

import org.txm.chartsengine.rcp.SWTChartsComponentsProvider;

import org.txm.core.preferences.TXMPreferences;

import org.txm.functions.TXMResult;

import org.txm.functions.specificities.SpecificitesResult;

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

/**

 * Base class of all charts SWT <code>IEditorInput</code> implementations.

 * @author sjacquot

 *

 */

public class ChartEditorInput implements IEditorInput {

	/**

	 * The name.

	 */

	protected String name;

	/**

	 * TXM result object.

	 */

	protected TXMResult resultData; 

	/**

	 * Chart type.

	 */

	protected String chartType;

	protected String preferencesNodeQualifier;

	/**

	 * 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 container (for example : can be a file, an AWT/Swing component as ChartPanel for JFC, etc.).

	 */

	protected Object chartContainer;

	/**

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

	 * @param resultData

	 * @param preferencesNodeQualifier

	 */

	public ChartEditorInput(TXMResult resultData, String preferencesNodeQualifier) {

		this(SWTChartsComponentsProvider.getCurrent(), resultData, preferencesNodeQualifier);

	}

	/**

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

	 * @param swtComponentsProvider

	 * @param resultData

	 * @param preferencesNodeQualifier

	 */

	public ChartEditorInput(SWTChartsComponentsProvider swtComponentsProvider, TXMResult resultData, String preferencesNodeQualifier) {

		this(swtComponentsProvider, resultData, preferencesNodeQualifier, resultData.getClass().getName());

	}

	/**

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

	 * @param swtComponentsProvider

	 * @param resultData

	 * @param preferencesNodeQualifier

	 * @param chartType

	 */

	public ChartEditorInput(SWTChartsComponentsProvider swtComponentsProvider, TXMResult resultData, String preferencesNodeQualifier, String chartType) {

		this(swtComponentsProvider, "Chart editor input", resultData, preferencesNodeQualifier, chartType, null);

	}

	/**

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

	 * @param swtComponentsProvider

	 * @param name

	 * @param resultData

	 * @param preferencesNodeQualifier

	 * @param chartType

	 * @param chartContainer

	 */

	public ChartEditorInput(SWTChartsComponentsProvider swtComponentsProvider, String name, TXMResult resultData, String preferencesNodeQualifier, String chartType, Object chartContainer) {

		this.swtChartsComponentsProvider = swtComponentsProvider;

		this.name = name;

		this.resultData = resultData;

		this.preferencesNodeQualifier = preferencesNodeQualifier;

		this.chartType = chartType;

		this.chartContainer = 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 String getName() {

		return this.name;

	}

	@Override

	public IPersistableElement getPersistable() {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	public String getToolTipText() {

		return this.getName();

	}

	@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 result data associated with the editor input.

	 * @return the resultData

	 */

	public TXMResult getResultData() {

		return resultData;

	}

	/**

	 * Sets the result data associated with the editor input.

	 * @param resultData the resultData to set

	 */

	public void setResultData(TXMResult resultData) {

		this.resultData = resultData;

	}

	/**

	 * Sets the name of the editor input.

	 * @param name the name to set

	 */

	public void setName(String name) {

		this.name = name;

	}

	// FIXME: became useless ?

//	/**

//	 * Sets the specific SWT chart components provider to use while the chart editor initialization.

//	 * This is used for creating an editor with a specific components provider therefore the global application components provider will not be used if this member is different from null.

//	 * @param swtChartComponentsProvider the swtComponentProvider to set

//	 */

//	public void setSWTChartComponentsProvider(SWTChartsComponentProvider swtChartComponentsProvider) {

//		this.swtChartComponentsProvider = swtChartComponentsProvider;

//	}

	/**

	 * Gets the SWT chart components provider linked to this editor input.

	 * @return the swtComponentProvider

	 */

	public SWTChartsComponentsProvider getSWTChartsComponentsProvider() {

		return this.swtChartsComponentsProvider;

	}

	@Override

	public boolean equals(Object obj)	{

		if(obj instanceof ChartEditorInput)	{

			// FIXME: validate these tests for all chart editors

//			if(this == obj)	{

//				return true;

//			};

			// Always recreate an editor for specificites result

			if(((ChartEditorInput) obj).getResultData() instanceof SpecificitesResult)	{

				return false;

			}

			// Always recreate an editor for partition dimension result

			if(((ChartEditorInput) obj).getResultData() instanceof Partition)	{

				return false;

			}

			return this.resultData == ((ChartEditorInput) obj).getResultData();

		}

		return false;

	}

	/**

	 * @return the chartContainer

	 */

	public Object getChartContainer() {

		return chartContainer;

	}

	/**

	 * @param chartContainer the chartContainer to set

	 */

	public void setChartContainer(Object chartContainer) {

		this.chartContainer = chartContainer;

	}

	/**

	 * @param swtChartsComponentsProvider the swtChartsComponentsProvider to set

	 */

	public void setSWTChartsComponentsProvider(SWTChartsComponentsProvider swtChartsComponentsProvider) {

		this.swtChartsComponentsProvider = swtChartsComponentsProvider;

	}

	/**

	 * @return the chartType

	 */

	public String getChartType() {

		return chartType;

	}

	/**

	 * @return the preferencesNodeQualifier

	 */

	public String getPreferencesNodeQualifier() {

		return preferencesNodeQualifier;

	}

	/**

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

	 */

	public void syncLocalPreferencesNode()	{

		//this.preferencesNodeQualifier = TXMPreferences.getId(this.resultData);

		// FIXME: persistence test

		TXMPreferences.putLocalString(this.resultData, ChartsEnginePreferences.CHART_TYPE, this.chartType);

		TXMPreferences.putLocalString(this.resultData, ChartsEnginePreferences.RESULT_DATA_TYPE, this.resultData.getClass().getName());

	}

}

package org.txm.chartsengine.rcp;

import java.awt.event.MouseEvent;

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

/**

 * Chart component interface.

 * @author sjacquot

 *

 */

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.

	 */

	public abstract void resetView();

	/**

	 * Pans the view.

	 * @param srcX

	 * @param srcY

	 * @param dstX

	 * @param dstY

	 * @param panFactor

	 */

	public abstract void pan(double srcX, double srcY, double dstX, double dstY, double panFactor);

	/**

	 * Gets the linked editor.

	 * @return

	 */

	public ChartEditorPart getChartEditor();

	/**

	 * Sets the linked editor.

	 * @param editor

	 */

	public void setChartEditor(ChartEditorPart editor);

	/**

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

	 * @param event

	 */

	public void updateMouseOverItem(MouseEvent event);

}

package org.txm.chartsengine.rcp.swt;

import org.eclipse.core.runtime.Assert;

import org.eclipse.jface.preference.FieldEditor;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.widgets.Combo;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

// FIXME : changeable JFace ComboFieldEditor, see if needed or not when the preferences structure for charts engine will be defined

public class ___EditableComboFieldEditor extends FieldEditor {

	/**

	 * The <code>Combo</code> widget.

	 */

	private Combo fCombo;

	/**

	 * The value (not the name) of the currently selected item in the Combo

	 * widget.

	 */

	private String fValue;

	/**

	 * The names (labels) and underlying values to populate the combo widget.

	 * These should be arranged as: { {name1, value1}, {name2, value2}, ...}

	 */

	private String[][] fEntryNamesAndValues;

	private Composite parent;

	/**

	 * Create the combo box field editor.

	 * 

	 * @param name

	 *            the name of the preference this field editor works on

	 * @param labelText

	 *            the label text of the field editor

	 * @param entryNamesAndValues

	 *            the names (labels) and underlying values to populate the combo

	 *            widget. These should be arranged as: { {name1, value1},

	 *            {name2, value2}, ...}

	 * @param parent

	 *            the parent composite

	 */

	public ___EditableComboFieldEditor(String name, String labelText, String[][] entryNamesAndValues, Composite parent) {

		init(name, labelText);

		this.parent = parent;

		Assert.isTrue(checkArray(entryNamesAndValues));

		fEntryNamesAndValues = entryNamesAndValues;

		createControl(parent);

	}

	/**

	 * Checks whether given <code>String[][]</code> is of "type"

	 * <code>String[][2]</code>.

	 * 

	 * @return <code>true</code> if it is ok, and <code>false</code> otherwise

	 */

	private boolean checkArray(String[][] table) {

		if(table == null) {

			return false;

		}

		for(int i = 0; i < table.length; i++) {

			String[] array = table[i];

			if(array == null || array.length != 2) {

				return false;

			}

		}

		return true;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.preference.FieldEditor#adjustForNumColumns(int)

	 */

	protected void adjustForNumColumns(int numColumns) {

		if(numColumns > 1) {

			Control control = getLabelControl();

			int left = numColumns;

			if(control != null) {

				((GridData) control.getLayoutData()).horizontalSpan = 1;

				left = left - 1;

			}

			((GridData) fCombo.getLayoutData()).horizontalSpan = left;

		}

		else {

			Control control = getLabelControl();

			if(control != null) {

				((GridData) control.getLayoutData()).horizontalSpan = 1;

			}

			((GridData) fCombo.getLayoutData()).horizontalSpan = 1;

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * org.eclipse.jface.preference.FieldEditor#doFillIntoGrid(org.eclipse.swt

	 * .widgets.Composite, int)

	 */

	protected void doFillIntoGrid(Composite parent, int numColumns) {

		int comboC = 1;

		if(numColumns > 1) {

			comboC = numColumns - 1;

		}

		Control control = getLabelControl(parent);

		GridData gd = new GridData();

		gd.horizontalSpan = 1;

		control.setLayoutData(gd);

		control = getComboBoxControl(parent);

		gd = new GridData();

		gd.horizontalSpan = comboC;

		gd.horizontalAlignment = GridData.FILL;

		control.setLayoutData(gd);

		control.setFont(parent.getFont());

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.preference.FieldEditor#doLoad()

	 */

	protected void doLoad() {

		updateComboForValue(getPreferenceStore().getString(getPreferenceName()));

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.preference.FieldEditor#doLoadDefault()

	 */

	protected void doLoadDefault() {

		updateComboForValue(getPreferenceStore().getDefaultString(getPreferenceName()));

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.preference.FieldEditor#doStore()

	 */

	protected void doStore() {

		if(fValue == null) {

			getPreferenceStore().setToDefault(getPreferenceName());

			return;

		}

		getPreferenceStore().setValue(getPreferenceName(), fValue);

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.preference.FieldEditor#getNumberOfControls()

	 */

	public int getNumberOfControls() {

		return 2;

	}

	/*

	 * Lazily create and return the Combo control.

	 */

	public Combo getComboBoxControl(Composite parent) {

		if(fCombo == null) {

			fCombo = new Combo(parent, SWT.READ_ONLY);

			fCombo.setFont(parent.getFont());

			for(int i = 0; i < fEntryNamesAndValues.length; i++) {

				fCombo.add(fEntryNamesAndValues[i][0], i);

			}

			fCombo.addSelectionListener(new SelectionAdapter() {

				public void widgetSelected(SelectionEvent evt) {

					String oldValue = fValue;

					String name = fCombo.getText();

					fValue = getValueForName(name);

					setPresentsDefaultValue(false);

					fireValueChanged(VALUE, oldValue, fValue);

				}

			});

		}

		return fCombo;

	}

	/*

	 * Given the name (label) of an entry, return the corresponding value.

	 */

	private String getValueForName(String name) {

		for(int i = 0; i < fEntryNamesAndValues.length; i++) {

			String[] entry = fEntryNamesAndValues[i];

			if(name.equals(entry[0])) {

				return entry[1];

			}

		}

		return fEntryNamesAndValues[0][0];

	}

	/*

	 * Set the name in the combo widget to match the specified value.

	 */

	private void updateComboForValue(String value) {

		fValue = value;

		for(int i = 0; i < fEntryNamesAndValues.length; i++) {

			if(value.equals(fEntryNamesAndValues[i][1])) {

				fCombo.setText(fEntryNamesAndValues[i][0]);

				return;

			}

		}

		if(fEntryNamesAndValues.length > 0) {

			fValue = fEntryNamesAndValues[0][1];

			fCombo.setText(fEntryNamesAndValues[0][0]);

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.preference.FieldEditor#setEnabled(boolean,

	 * org.eclipse.swt.widgets.Composite)

	 */

	public void setEnabled(boolean enabled, Composite parent) {

		super.setEnabled(enabled, parent);

		getComboBoxControl(parent).setEnabled(enabled);

	}

	/**

	 * 

	 * @param entryNamesAndValues

	 */

	public void setEntryNamesAndValues(String[][] entryNamesAndValues)	{

		Assert.isTrue(checkArray(entryNamesAndValues));

		this.fEntryNamesAndValues = entryNamesAndValues;

		this.getComboBoxControl(parent).dispose();

		this.fCombo = null;

		createControl(this.parent);

		// FIXME : fonctionne mal, la sélection dans la combo box se fait bien mais c'est l'ancienne valeur d'index 0 qui est envoyée en tant que pref 

//		this.fCombo.select(0);

	}

}

package org.txm.chartsengine.rcp.swt;

import java.awt.Component;

import java.util.ArrayList;

import java.util.EventListener;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.MenuItem;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.menus.IMenuService;

import org.txm.chartsengine.rcp.IChartComponent;

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

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

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

/**

 * Chart drawing area composite.

 * @author sjacquot

 *

 */

public abstract class ChartComposite extends Composite {

	protected static final String CONTEXT_MENU_ID =  "ChartEditorContextMenu"; //$NON-NLS-1$

	/**

	 * Custom tool tip.

	 */

	// FIXME: tests HTML tool tips

	protected ___CustomHTMLToolTip toolTip;

	/**

	 * The chart component.

	 */

	protected IChartComponent chartComponent;

	/**

	 * Context menus.

	 */

	protected ArrayList<Menu> contextMenus;

	protected ChartEditorPart chartEditor;

	/**

	 *

	 * @param parent

	 * @param style

	 */

	public ChartComposite(ChartEditorPart chartEditor, Composite parent, int style) {

		super(parent, style);

		this.chartEditor = chartEditor;

		this.contextMenus = new ArrayList<Menu>();

		this.contextMenus.add(null);

		this.contextMenus.add(null);

	}

	/**

	 * Creates the pop up menu dedicated to empty area location click event.

	 */

	public void initEmptyAreaContextMenu()	{

		// FIXME: tests de liens vers menu RCP + changement dynamique d'une entrée du menu => ne fonctionne pas pour la modif dynamique

//		System.err.println("ChartComposite.initEmptyAreaContextMenu()");

		MenuManager menuManager = new MenuManager();

////		menuManager.setRemoveAllWhenShown(true);

		IMenuService menuService = (IMenuService) PlatformUI.getWorkbench().getActiveWorkbenchWindow().getService(IMenuService.class);

		menuService.populateContributionManager(menuManager, "popup:" + CONTEXT_MENU_ID); //$NON-NLS-1$

		Menu menu = menuManager.createContextMenu(this);

		menuManager.update(true);

	    this.contextMenus.set(EventCallBack.AREA_EMPTY, menu);

		// FIXME: manual creation

//		Menu menu = new Menu(this);

//		MenuItem exportViewItem = new MenuItem(menu, SWT.CASCADE);

//	    exportViewItem.setText(SWTComponentsProviderMessages.ChartEditorToolBar_SHARED_BUTTON_EXPORT_VIEW_LABEL + "...");

//	    exportViewItem.setImage(IImageKeys.getImage(IImageKeys.CHARTS_EXPORT_VIEW));

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

//	    	exportViewItem.addSelectionListener(new BaseSelectionListener(this.chartComponent.getChartEditor(), BaseSelectionListener.EXPORT_VIEW));

//	    }

//	    

//	    this.contextMenus.set(EventCallBack.AREA_EMPTY, menu);

	}

	/**

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

	 */

	public void initItemAreaContextMenu()	{

		Menu menu = new Menu(this);

	    MenuItem chartEntityLabelItem = new MenuItem(menu, SWT.CASCADE);

	    //chartEntityLabelItem.setText(""); // this string is dedicated to be overridden by the current selected chart entity label/name 

	    // FIXME : tests

//	    MenuItem refreshItem = new MenuItem(menu, SWT.NONE);

//	    refreshItem.setText("Refresh");

//	    MenuItem deleteItem = new MenuItem(menu, SWT.NONE);

//	    deleteItem.setText("Delete");

//

	    Menu newMenu = new Menu(menu);

	    chartEntityLabelItem.setMenu(newMenu);

//	    MenuItem shortcutItem = new MenuItem(newMenu, SWT.NONE);

//	    shortcutItem.setText("Shortcut");

//	    MenuItem iconItem = new MenuItem(newMenu, SWT.NONE);

//	    iconItem.setText("Icon");

	    this.contextMenus.set(EventCallBack.AREA_ITEM, menu);

	}

	/**

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

	 * @param index

	 */

	public void setCurrentContextMenu(int index)	{

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

	}

	/**

	 * Gets the menu specified by its index.

	 * @param index

	 * @return

	 */

	public Menu getContextMenu(int index)	{

		return this.contextMenus.get(index);

	}

	/**

	 * Loads the chart from specified data.

	 * @param data

	 */

	public abstract void loadChart(Object data);

	/**

	 * Reloads the chart from the chart object stored into the composite.

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

	 */

	public abstract void reloadChart();