Laboratoire ICAR » Plateforme TXM

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

public class WordCloudEditor extends ChartEditorPart<WordCloud> {

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

		ChartEditorPart.openEditor(wordCloud);

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

		ChartEditorPart.openEditor(partitionDimensions, partitionDimensions.getClass().getName());

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

public class PartitionDimensionsEditor extends ChartEditorPart<PartitionDimensions> {

import org.txm.rcp.editors.TXMEditorPart;

public class CooccurrencesEditor extends TXMEditorPart<Cooccurrence> {

//				//TXMEditorPart.compute(CooccurrencesEditor.this.getResultData(), true, CooccurrencesEditor.this);

				TXMEditorPart.packColumns(viewer);

import org.txm.rcp.editors.TXMEditorPart;

			TXMEditorPart.openEditor(cooc, CooccurrencesEditor.ID);

//			CooccurrencesEditor conceditor = (CooccurrencesEditor) TXMEditorPart.openEditor(new TXMResultEditorInput(corpus, new TXMParameters()), "CooccurrencesEditor"); //$NON-NLS-1$

//			CooccurrencesEditor conceditor = (CooccurrencesEditor) TXMEditorPart.openEditor(new TXMResultEditorInput(corpus, new TXMParameters()), "CooccurrencesEditor"); //$NON-NLS-1$

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

import org.txm.rcp.editors.TXMEditorPart;

		((ChartEditorPart)editors.get(4)).setParentMultiPagesEditor(this);

		ChartEditorPart caFactorialMapEditorPart = new CAFactorialMapChartEditor(new ChartEditorInput(ca));

		ChartEditorPart caSingularValuesEditorPart = new ChartEditorPart(SWTChartsComponentsProvider.getCurrent().createChartEditorInput(eigenvalues));

	public ChartEditorPart getChartEditor()	{

		return (ChartEditorPart) this.editors.get(0);

		// Give the focus to the CA factorial map ChartEditorPart instead of the parent MultiPageEditorPart

		((ChartEditorPart)editors.get(0)).close(deleteResult);

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

public class CAFactorialMapChartEditor extends ChartEditorPart<CA> {

			//ChartEditorPart.compute(ca);

			init(symbol, specIndex, lexicalTable, Arrays

					.asList(lexicalTable.getRowNames().asStringsArray()), Arrays.asList(lexicalTable.getColNames().asStringsArray()), lexicalTable.getProperty().getName(), this.maxScore); 

			init(si.getSymbol(), specIndex, lexicalTable, Arrays

					.asList(lexicalTable.getRowNames().asStringsArray()), Arrays.asList(lexicalTable.getColNames().asStringsArray()),

					"TLNONAME: " + lexicalTable.getProperty().getName(), this.maxScore); //$NON-NLS-1$

	protected void init(String symbol, double[][] specIndex, LexicalTable table, List<String> typeFocus, List<String> partFocus, String name, int maxScore) throws StatException {

		this.lexicalTable = table;

		if (table == null) {

		this.lexicalTable = table;

		this.colnames = partFocus;

		this.rownames = typeFocus;

		if (typeFocus != null && typeFocus.size() != 0) {

			if (typeFocus.size() != specIndex.length) {

						SpecificitiesCoreMessages.bind(SpecificitiesCoreMessages.ComputeError_FOUND_AND_WANTED_ROWS_MISMATCH, typeFocus.size(), specIndex.length));

			rowindex = ArrayIndex.getIndex(table.getRowNames().asStringsArray(), typeFocus.toArray(new String[] {}));

//		if (partFocus != null && partFocus.size() != 0) {

//			if (partFocus.size() != specIndex[0].length) {

//						SpecificitiesCoreMessages.SpecificitesResult_7 + partFocus.size()

		if (name.length() > 20) name = name.substring(0, 19) + "...";

import org.txm.rcp.editors.TXMEditorPart;

		TXMEditorPart.openEditor(index, IndexEditor.class.getName());

import org.txm.rcp.editors.TXMEditorPart;

		TXMEditorPart.openEditor(lexicon, DictionnaryEditor.class.getName());

import org.txm.rcp.editors.TXMEditorPart;

public class IndexEditor extends TXMEditorPart<Index> {

		TXMEditorPart.initContextMenu(this.viewer.getTable(), "IndexEditorContextMenu", this.getSite(), this.viewer); // $NON-NLS-1$

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

			//ChartEditorPart.compute(progression, tmpSWTComponentsProvider);

			//ChartEditorPart.compute(progression);

		ChartEditorPart.openEditor(progression);

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

import org.txm.rcp.editors.TXMEditorPart;

public class ProgressionEditor extends ChartEditorPart<Progression> {

		protected TXMEditorPart editor;

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

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

	protected ChartEditorPart chartEditor;

	public void setChartEditor(ChartEditorPart chartEditor) {

	public ChartEditorPart getChartEditor() {

package org.txm.chartsengine.rcp.editors;

import java.io.File;

import java.util.ArrayList;

import javax.swing.JComponent;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.Platform;

import org.eclipse.swt.SWT;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Group;

import org.eclipse.ui.IPartListener;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.part.EditorPart;

import org.eclipse.ui.part.MultiPageEditorPart;

import org.txm.chartsengine.core.ChartsEngine;

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

import org.txm.chartsengine.rcp.SWTChartsComponentsProvider;

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

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

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

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

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

import org.txm.rcp.editors.TXMEditorPart;

import org.txm.utils.logger.Log;

/**

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

 * @author sjacquot

 *

 */

public abstract class ChartEditorPart<T extends ChartResult> extends TXMEditorPart<ChartResult>{

	/**

	 * The tool bar.

	 */

	protected ChartEditorToolBar chartToolBar;

	/**

	 * The advanced tool bar.

	 */

	protected AdvancedChartEditorToolBar advancedChartToolBar;

	/**

	 * The advanced rendering parameters composite.

	 */

	protected Composite advancedToolBarComposite;

	/**

	 * The advanced rendering parameters group.

	 */

	protected Group advancedToolBarGroup;

	/**

	 * The chart drawing area composite.

	 */

	protected ChartComposite chartComposite;

	/**

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

	 */

	protected boolean wasAlreadyOpened;

	/**

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

	 */

	protected MultiPageEditorPart parentMultiPagesEditor = null;

	/**

	 * Linked editors.

	 */

	//FIXME: should be at TXMEditorPart level

	protected ArrayList<EditorPart> linkedEditors = null;

	/**

	 *

	 */

	public ChartEditorPart()	{

		super();

	}

	/**

	 * Returns the result object associated with the editor through its editor input.

	 * @return

	 */

	public T getResult()	{

		return (T) this.getEditorInput().getResult();

	}

	/**

	 * 

	 * @param swtComponentsProvider

	 * @param chartEditorInput

	 */

	protected ChartEditorPart(SWTChartsComponentsProvider swtComponentsProvider, ChartEditorInput chartEditorInput) {

		this.setInput(chartEditorInput);

		this.setPartName(chartEditorInput.getName());

		this.wasAlreadyOpened = false;

	}

	/**

	 * 

	 * @param chartEditorInput

	 */

	public ChartEditorPart(ChartEditorInput<ChartResult> chartEditorInput) {

		this(SWTChartsComponentsProvider.getCurrent(), chartEditorInput);

	}

	@Override

	public final void __createPartControl(Composite parent) {

		// Toolbar

		this.chartToolBar = new ChartEditorToolBar(this, SWT.FLAT | SWT.RIGHT);

		//this.chartToolBar = new ChartEditorToolBar(this.topToolBar, SWT.FLAT | SWT.RIGHT, this);

		//this.chartToolBar.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_RED));

		// Advanced tool bar

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

		Group group = this.topToolBar.installGroup("Rendering parameters", "Show/Hide rendering parameters", "platform:/plugin/org.txm.chartsengine.rcp/icons/show_rendering_parameters.png", false);

		this.advancedChartToolBar = new AdvancedChartEditorToolBar(group, SWT.FLAT, this);

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

//		this.advancedToolBarComposite.pack(true);

		// Remove parent composites

		//TODO MD: hack ?

		this.resultArea.dispose();

		// Chart composite

		this.chartComposite = this.getSWTChartsComponentsProvider().createComposite(this, parent);

		GridData gd = new GridData(GridData.FILL_BOTH);

//		gd.grabExcessVerticalSpace = true;

//		gd.grabExcessHorizontalSpace = true;

		//gd.horizontalSpan = 2; // 2 for match the command parameters toolbar AND the chart toolbar

		this.chartComposite.setLayoutData(gd);

		// Re-add the bottom toolbar

		//TODO MD: hack ?

		//this.bottomToolBar = new TXMEditorToolBar(this, SWT.FLAT, "bottom");

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

		//this.refresh(false);

//

//		}

	}

	/**

	 * Initializes the default context menus.

	 */

	public void initDefaultContextMenus()	{

		SWTChartsComponentsProvider.initDefaultContextMenus(this.chartComposite);

	}

	/**

	 * 

	 * @param result

	 * @return

	 */

//	public static ChartEditorPart openEditor(ChartResult result) {

//		return openEditor(result, SWTChartsComponentsProvider.getCurrent());

//	}

	public static void openEditor(ChartResult result) {

		openEditor(result, result.getClass().getName());

	}

	public static void openEditor(ChartResult result, String editorPartId)	{

		compute(new ChartEditorInput(result), editorPartId, false, null);

	}

	/**

	 * 

	 * @param result

	 * @param chartsComponentsProvider

	 * @return

	 */

	public static void openEditor(ChartResult result, SWTChartsComponentsProvider chartsComponentsProvider) {

		compute(new ChartEditorInput(result), result.getClass().getName(), false, null);

		//return chartsComponentsProvider.openEditor(result);

	}

	@Override

	public void updateEditorFromResult(boolean update) {

		// nothing to do

	}

	@Override

	protected final void __updateEditorFromResult(boolean update) {

		// loading chart

		this.getResult().subTask("Loading chart.");

		this.loadChart();

		// if editor wasn't exist:

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

		if(!update && !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.

					initDefaultContextMenus();

					// registers user entries event call back extensions

					registerEventCallBackExtensions();

					//FIXME: test to contribute to menu only in some context

					// create chart editor part context

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

	//				contextService.activateContext(ChartEditorPart.class.getName());

	//				// create chart composite context

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

					//FIXME: description test

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

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

					initializeAWTDelegationListeners();

				}

			});

		}

	}

	/**

	 * Registers user entries event call back extensions.

	 */

	protected void registerEventCallBackExtensions()	{

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

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

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

			if(

				(

						contributions[i].getAttribute("chartsEngineName") == null || //$NON-NLS-1$ // for callback that can be used for all charts engine implementations 

						contributions[i].getAttribute("chartsEngineName").equals(this.getChartsEngine().getName()) //$NON-NLS-1$

				)

				&&

				contributions[i].getAttribute("resultDataClass") != null //$NON-NLS-1$

				&& contributions[i].getAttribute("resultDataClass").equals(this.getResult().getClass().getName()) //$NON-NLS-1$

				&& ((contributions[i].getAttribute("chartType") == null && this.getChartType() == null

					||

					contributions[i].getAttribute("chartType") != null && this.getChartType() != null && contributions[i].getAttribute("chartType").equals(this.getChartType())

					)  //$NON-NLS-1$

				)

			)	{

				try {

					EventCallBack eventCallBack = (EventCallBack)contributions[i].createExecutableExtension("class");  //$NON-NLS-1$

					eventCallBack.setChartEditor(this);

					EventCallBackHandler mouseHandler = this.chartComposite.getMouseCallBackHandler();

					if(mouseHandler != null && mouseHandler.getEventCallBack(eventCallBack.getClass()) == null)	 {

						Log.info("ChartEditorPart.createPartControl(): call back of type " + eventCallBack.getClass()

								+ " registered in mouse handler (chart editor = " + this.getClass()

								+ ", result data class = " + this.getResult().getClass()

								+ ", chart type = " + this.getChartType()

								+ ").");

						mouseHandler.registerEventCallBack(eventCallBack);

					}

					EventCallBackHandler keyboardHandler = this.chartComposite.getKeyCallBackHandler();

					if(keyboardHandler != null && keyboardHandler.getEventCallBack(eventCallBack.getClass()) == null)	 {

						Log.info("ChartEditorPart.createPartControl(): call back of type " + eventCallBack.getClass()

								+ " registered in key handler (chart editor = " + this.getClass()

								+ ", result data class = " + this.getResult().getClass()

								+ ", chart type = " + this.getChartType()

								+ ").");

						keyboardHandler.registerEventCallBack(eventCallBack);

					}

				}

				catch(CoreException e) {

					e.printStackTrace();

				}

				break;

			}

		}

	}

	/**

	 * 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("ChartEditorPart.activate(): current active editor = " + PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart());

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

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

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

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

		}

	}

	/**

	 * Forces the Composite to get the focus.

	 */

	public void forceFocus()	{

		// FIXME: debug

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

		//this.chartComposite.setFocus();

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

	}

	/**

	 * Initialize Swing/AWT events delegation.

	 * @param swingComponent

	 */

	protected void initializeAWTDelegationListeners()	{

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

		SWTChartsComponentsProvider.initializeAWTDelegationListeners(this, (JComponent) this.getEditorInput().getChartContainer());

	}

	/**

	 * Convenience method the get the casted linked editor input.

	 * @return the editorInput

	 */

	public ChartEditorInput<T> 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();

	}

	/**

	 *  Clears the selected items in chart.

	 */

	public void clearChartItemsSelection()	{

		this.chartComposite.clearChartItemsSelection();

	}

	/**

	 * 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.chartComposite.copyChartViewToClipboard();

	}

	/**

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

	 * @param resetView

	 * @param clearChartItemsSelection

	 */

	public void loadChart()	{

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

			@Override

			public void run() {

				chartComposite.loadChart(

						getResult().needsToResetView(), 

						getResult().needsToClearItemsSelection());

			}

		});

	}

	/**

	 * Creates the chart container component from the chart object stored into the composite.

	 */

	public void createChartContainer()	{

		this.getSWTChartsComponentsProvider().createChartContainer(this.getEditorInput());

	}

	/**

	 * 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 tool bar of this editor.

	 * @return the toolBar

	 */

	public ChartEditorToolBar getToolBar() {

		return chartToolBar;

	}

	/**

	 * Returns the advanced tool bar of this editor.

	 * @return

	 */

	public AdvancedChartEditorToolBar getAdvancedToolBar()	{

		return this.advancedChartToolBar;

	}

	/**

	 * 

	 * @return

	 */

	public String getChartType()	{

		return this.getResult().getChartType();

	}

	/**

	 * Returns the chart associated with the editor.

	 * @return

	 */

	public Object getChart()	{

		return this.getResult().getChart();

	}

	/**

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

	 * @return

	 */

	public SWTChartsComponentsProvider getSWTChartsComponentsProvider()	{

		return this.getEditorInput().getSWTChartsComponentsProvider();

	}

	/**

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

	 * @return

	 */

	public ChartsEngine getChartsEngine()	{

		return this.getEditorInput().getChartsEngine();

	}

	/**

	 * 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

	 */

	//FIXME: should be at TXMEditorPart 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("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

	 */

	//FIXME: should be at TXMEditorPart 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 TXMEditorPart 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 TXMEditorPart 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 TXMEditorPart 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;

//	}

	/**

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

	 * @return the wasAlreadyOpened

	 */

	public boolean wasAlreadyOpened() {

		return wasAlreadyOpened;

	}

	/**

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

	 * @param wasAlreadyOpened the wasAlreadyOpened to set

	 */

	public void setWasAlreadyOpened(boolean wasAlreadyOpened) {

		this.wasAlreadyOpened = wasAlreadyOpened;

	}

	/**

	 * Checks whatever the chart composite has the focus or not.

	 * @return <code>true</code> if the chart composite has the focus otherwise <code>false</code>

	 */

	public boolean hasFocus()	{

		return this.chartComposite.hasFocus();

	}

	/**

	 * Gets the chart composite.

	 * @return the chartComposite

	 */

	public ChartComposite getChartComposite() {

		return chartComposite;

	}

	/**

	 * Gets the chart toolbar.

	 * @return the chartToolBar

	 */

	public ChartEditorToolBar getChartToolBar() {

		return chartToolBar;

	}

	@Override

	public void updateResultFromEditor() {

		// does nothing by default

	}

	@Override

	public Composite getToolBarContainer(String toolbarLocalId) {

		if (ChartEditorToolBar.ID.equals(toolbarLocalId)) {

			return this.getTopToolBarContainer();

		}

		return super.getToolBarContainer(toolbarLocalId);

	}

}