Laboratoire ICAR » Plateforme TXM

import org.txm.utils.logger.Log;

/**

 * - a main toolbar at the top

 * - display area

 * - a bottom toolbar at the bottom of the editor

 *

 */

public abstract class TXMEditor<T extends TXMResult> extends EditorPart implements ITXMResultEditor<T> {

	/**

	 * ID to use in plugin.xml to contribute to the top toolbar.

	 */

	public final static String TOP_TOOLBAR_ID = "TXMEditorTopToolBar"; //$NON-NLS-1$

	public final static String BOTTOM_TOOLBAR_ID = "TXMEditorBottomToolBar"; //$NON-NLS-1$

	public final static String COMPUTING_PARAMETERS_GROUP_ID = TXMUIMessages.parameters;

	/**

	 * ID defined in plugin.xml for the compute button contribution.

	 */

	public final static String TOP_TOOLBAR_COMPUTE_BUTTON_ID = "compute"; //$NON-NLS-1$

	/**

	 * The editor main tool bar, positioned at the top of the editor.

	 */

	protected TXMEditorToolBar topToolBar;

	/**

	 * The main panel containing the displayed result

	 */

	private GLComposite resultArea;

	/**

	 * The editor bottom tool bar, positioned at the bottom of the editor.

	 */

	protected TXMEditorToolBar bottomToolBar;

	/**

	 * The parameters groups are added to this composite. contains the sub widgets of the default Top toolbar

	 */

	private GLComposite extendedParametersComposite;

	/**

	 */

	protected GLComposite mainParametersComposite;

	/**

	 * Command extended parameters group that can be hidden.

	 */

	protected Group extendedParametersGroup;

	/**

	 * The SWT parent Composite.

	 */

	protected Composite parent;

	/**

	 * contains the default bottom toolbars widget

	 */

	protected Composite bottomToolBarContainer;

	/**

	 * Computing tool item button.

	 */

	protected ToolItem computeButton;

	/**

	 */

	// FIXME: SJ: useless?

	/**

	 * contains bottom toolbar subwidgets (installed grouped, etc.)

	 */

	private GLComposite bottomSubWidgetsComposite;

	private GLComposite firstLineComposite;

	private boolean createPartControlDoneSucessfully = true; // FIXME: MD: for now... muahahaha

	/**

	 * installed extensions

	 */

	protected HashSet<TXMEditorExtension<T>> extensions = new HashSet<TXMEditorExtension<T>>();

	/**

	 * Linked editors.

	 */

	protected ArrayList<EditorPart> linkedEditors = null;

	/**

	 * debug purpose variable -> easier to fetch information that the getResult() method

	 */

	protected T result;

	/**

	 * To store or edit the dirty state of the editor from widget.

	 */

	protected boolean dirty = true;

	private boolean locked = false;

	/**

	 * Default constructor.

	 */

	public TXMEditor() {

		super();

	}

	/**

	 * Creates an editor and an editor input containing the specified result.

	 * @param result

	 */

	public TXMEditor(TXMResult result) {

		this(new TXMResultEditorInput<TXMResult>(result));

	}

	/**

	 * Creates an editor with the specified editor input.

	 * @param editorInput

	 */

	public TXMEditor(TXMResultEditorInput<TXMResult> editorInput) {

	}

	@Override

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

		this.setSite(site);

		this.setInput(input);

		this.result = this.getEditorInput().getResult(); // store result for debug purpose

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

		// so it seems better to use Adapters if it's possible or keep this solution below

		this.setPartName(input.getName());

		// fetch extensions

		this.initExtensions();

	}

	/**

	 * Initializes plug-ins extensions.

	 */

		IConfigurationElement[] config = Platform.getExtensionRegistry().getConfigurationElementsFor(TXMEditorExtension.EXTENSION_ID);

		if (config.length > 0) {

			for (IConfigurationElement e : config) {

				try {

					final Object o = e.createExecutableExtension("class"); //$NON-NLS-1$

					if (o instanceof TXMEditorExtension) {

						ISafeRunnable runnable = new ISafeRunnable() {

							@Override

							public void handleException(Throwable exception) {

							}

							@Override

							public void run() throws Exception {

								@SuppressWarnings("unchecked")

								TXMEditorExtension<T> ext = ((TXMEditorExtension<T>) o);

								TXMResult r = getResult();

								if (r == null) return;

								if (ext.getTXMResultValidClasses() == null || ext.getTXMResultValidClasses().contains(getResult().getClass())) {

									ext.setEditor(TXMEditor.this);

									extensions.add(ext);

								}

						};

						SafeRunner.run(runnable);

					}

					Log.severe("Exception while installing " + e.getName() + ": " + ex.getLocalizedMessage()); //$NON-NLS-1$ //$NON-NLS-2$

				}

			}

		}

		IPartListener2 pl = new IPartListener2() {

			// ... Other methods

			public void partClosed(IWorkbenchPartReference partRef) {

				if (partRef.getId().equals(TXMEditor.this.getClass().getName())) { // called after this.doSave()

					for (TXMEditorExtension<T> extension : extensions) {

						try {

							if (extension.isDirty()) {

								extension.discardChanges();

							}

							// TODO Auto-generated catch block

							e.printStackTrace();

						}

					}

				}

			}

			@Override

			public void partActivated(IWorkbenchPartReference partRef) {

				CorporaView.refresh();

			}

			@Override

			@Override

			@Override

			@Override

			@Override

			@Override

		};

		this.getEditorSite().getPage().addPartListener(pl);

	}

	/**

	 * the composite containing the main parameters, the top toolbar and eventually other top toolbars

	 * @return

	 */

	public GLComposite getFirstLineComposite() {

		return firstLineComposite;

	}

	/**

	 * Gets the shell of the parent composite if exists and not disposed otherwise the Display default active shell.

	 * @return

	 */

	public Shell getShell() {

		return Display.getDefault().getActiveShell();

	}

	/**

	 * @return the composite displayed before the toptoolbar, containing the minimal parameters widgets

	 */

	public GLComposite getMainParametersComposite() {

		return mainParametersComposite;

	}

	/**

	 * Creates the default toolbar (empty) and default result area (empty).

	 * 

	 */

	@Override

	public final void createPartControl(Composite parent) {

		try {

			this.parent = parent;

			// disable the rendering while creating the widgets

			// FIXME: SJ: would be very nice to do that to avoid to see the empty tables before the refresh() that fill the UI.

			// the re-enabling is done in refresh() but the EditionEditor doesn't seem to call refresh() so it breaks it

			// to hide and display the extended parameters composite

			this.initParentLayout(parent, 1);

			// contains the minimal panels and top toolbars

			this.firstLineComposite = new GLComposite(parent, SWT.NONE, "Editor first line"); //$NON-NLS-1$

			this.firstLineComposite.getLayout().numColumns = 2;

			this.firstLineComposite.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, false));

			this.mainParametersComposite = new GLComposite(this.firstLineComposite, SWT.NONE, "Main parameters area"); //$NON-NLS-1$

			this.mainParametersComposite.setLayoutData(new GridData(GridData.FILL, GridData.FILL, false, false));

			this.mainParametersComposite.getLayout().marginLeft = 5;

			this.mainParametersComposite.getLayout().horizontalSpacing = 5;

			this.extendedParametersComposite = new GLComposite(parent, SWT.NONE, "Extended parameters area"); //$NON-NLS-1$

			this.extendedParametersComposite.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));

			this.topToolBar = new TXMEditorToolBar(this, this.firstLineComposite, this.extendedParametersComposite, SWT.FLAT | SWT.RIGHT, TOP_TOOLBAR_ID);

			// store the Compute button to access if later, especially from subclasses

			this.computeButton = topToolBar.getItemByContributionId(TOP_TOOLBAR_COMPUTE_BUTTON_ID);

			// computing parameters components

			boolean showExtendedParameters = false;

			// only show the area if the result can not compute and is dirty

					"icons/show_computing_parameters.png",  //$NON-NLS-1$

					"icons/hide_computing_parameters.png",  //$NON-NLS-1$

					showExtendedParameters);

			// display main area

			this.resultArea = new GLComposite(parent, SWT.NONE, "Result area"); //$NON-NLS-1$

			this.resultArea.setLayoutData(new GridData(GridData.FILL_BOTH));

			// create the bottom tool bar

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

			this.bottomToolBarContainer.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, false));

			RowLayout rl = new RowLayout(SWT.HORIZONTAL);

			rl.marginTop = rl.marginHeight = rl.marginWidth = rl.marginBottom = 0;

			this.bottomToolBarContainer.setLayout(rl);

			this.bottomSubWidgetsComposite = new GLComposite(parent, SWT.NONE, "Bottom parameters area"); //$NON-NLS-1$

				this.bottomSubWidgetsComposite.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, false));

			}

			this.bottomToolBar = new TXMEditorToolBar(this, this.bottomToolBarContainer, this.bottomSubWidgetsComposite, SWT.FLAT, "bottom"); //$NON-NLS-1$

			this.notifyExtensions("notifyStartOfCreatePartControl"); //$NON-NLS-1$

			this._createPartControl(); // child editor creates its parameters and displays widgets

			this.notifyExtensions("notifyEndOfCreatePartControl"); //$NON-NLS-1$

			this.firstLineComposite.pack();

			this.extendedParametersGroup.pack();

			// remove empty toolbar

			if (this.bottomToolBar.getItems().length == 0) {

				this.bottomToolBar.dispose();

			}

			// remove empty toolbar

			if (this.topToolBar.getItems().length == 0) {

				this.topToolBar.dispose();

			}

			// uninstall parameters group if not used

			if (this.extendedParametersGroup.getChildren().length == 0) {

				this.topToolBar.unInstallGroup(COMPUTING_PARAMETERS_GROUP_ID);

			}

			// FIXME: SJ: this code doesn't work even if we call removeComputeButton()

			// remove empty first line composite

			if (this.getResult() != null && this.getResult().isLocked()) {

				this.setLocked(true);

			}

			// disable the compute button, it will be re-enable or not later when the UI will check if the editor is dirty or not

			// dirty state according to the future compute that will be launched by TXMEditor.openEditor()

				this.dirty = false;

			}

			this.setDirty(this.dirty);

		}

			Log.severe(TXMCoreMessages.bind("TXMEditor.createPartControl(): can not create the editor for result {0}.", this.getResult())); //$NON-NLS-1$

			e.printStackTrace();

			createPartControlDoneSucessfully = false;

		}

	}

	public void setLocked(boolean b) {

		this.locked = b;

		this.firstLineComposite.setEnabled(!b);

	}

	public boolean isLocked() {

		return locked;

	}

	/**

	 * shortcut to call the notify* methods of all extension

	 * 

	 * @throws NoSuchMethodException

	 */

	protected void notifyExtensions(final String step) {

		if (!step.startsWith("notify")) return; //$NON-NLS-1$

		ArrayList<TXMEditorExtension<T>> errors = new ArrayList<TXMEditorExtension<T>>();

		for (final TXMEditorExtension<T> ext : extensions) {

			//

			try {

				java.lang.reflect.Method method;

				method = ext.getClass().getMethod(step);

				if (method != null) {

					method.invoke(ext);

					ext.notify(step);

				}

				Log.printStackTrace(e);

			}

		}

		extensions.removeAll(errors);

	}

	/**

	 * Subclasses manual creation method called after TXMEditor.createPartControl is called.

	 * 

	 * Use this method to set your own widgets in the minimal parameters area, the top toolbar, parameters group, the result area and the bottom toolbar

	 */

	public abstract void _createPartControl() throws Exception;

	/**

	 * Use this method to add widget next to the default Bottom toolbar

	 * 

	 */

	public Composite getBottomToolBarContainer() {

		return bottomToolBarContainer;

	}

	/**

	 * Gets the top toolbar.

	 * @return the default Top toolbar of TXMEditors

	 */

	public TXMEditorToolBar getTopToolbar() {

		return topToolBar;

	}

	/**

	 * Gets the result display area.

	 * The user must configure its layout.

	 * @return

	 */

	public GLComposite getResultArea() {

		return resultArea;

	}

	/**

	 * Gets the bottom toolbar.

	 * @return the default bottom toolbar of editors

	 */

	public TXMEditorToolBar getBottomToolbar() {

		return bottomToolBar;

	}

	/**

	 * Creates the parent layout with some configuration to make children composite visible/invisible.

	 * 

	 * @param colSpan

	 */

		GridLayout gl = GLComposite.createDefaultLayout(1);

		parent.setLayout(gl);

	}

	/**

	 * Gets the extended parameters Group widget.

	 * Put here you main parameter widgets using RowData data layout.

	 * 

	 */

	public Group getExtendedParametersGroup() {

		return this.extendedParametersGroup;

	}

	@Override

	public boolean isSaveAsAllowed() {

		// TODO Auto-generated method stub

		return false;

	}

	@Override

	public void doSave(final IProgressMonitor monitor) {

		// FIXME: SJ: to discuss. A this moment the save is automatically done or not in TXMResult.compute() according to a preference of the TBX

		/// FIXME: SJ: dirty state tests

		if (parent != null && !parent.isDisposed()) {

			parent.getDisplay().asyncExec(new Runnable() {

				@Override

				public void run() {

					compute(true);

					TXMEditor.this.setDirty(false);

				}

			});

		}

		notifyExtensions("notifyDoSave"); //$NON-NLS-1$

		firePropertyChange(IEditorPart.PROP_DIRTY);

	}

	@Override

	public void doSaveAs() {

		// TODO Auto-generated method stub

	}

	@Override

	public void dispose() {

		notifyExtensions("notifyDispose"); //$NON-NLS-1$

		super.dispose();

	}

	/**

	 * Sets the dirty state of the editor.

	 * Also sets the result dirty state to true if editor is dirty.

	 * @param dirty

	 */

	public void setDirty(boolean dirty) {

		this.dirty = dirty;

		// FIXME: SJ: future version that enable the button ONLY if the result can compute

		// need to check all canCompute() result methods before enabling it

		firePropertyChange(IEditorPart.PROP_DIRTY);

		CorporaView.refreshObject(this.result);

	}

	@Override

	public boolean isDirty() {

		boolean dirty = this.dirty;

		for (TXMEditorExtension<T> extension : this.extensions) {

			try {

				dirty = dirty || extension.isDirty();

				e.printStackTrace();

			}

		}

		return dirty;

	}

	@Override

	public boolean isSaveOnCloseNeeded() {

		boolean needed = false;

		for (TXMEditorExtension<T> extension : this.extensions) {

			try {

				needed = needed || (extension.isSaveOnCloseNeeded() && extension.isDirty());

				e.printStackTrace();

			}

		}

		return needed;

	}

	@Override

	public void setFocus() {

		// FIXME SJ: this code leads to a bug, the focus must not be regiven to the main parameter after each computing of all result editors

		CorporaView.focus(this.getResult());

	}

	@SuppressWarnings("unchecked")

	@Override

	public TXMResultEditorInput<T> getEditorInput() {

		return (TXMResultEditorInput<T>) super.getEditorInput();

	}

	/**

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

	 * @return

	 */

		return this.getEditorInput().getResult();

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or default preferences nodes.

	 * @param key

	 * @return

	 */

		return this.getEditorInput().getResult().getIntParameterValue(key);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or default preferences nodes.

	 * @param key

	 * @return

	 */

		return this.getEditorInput().getResult().getFloatParameterValue(key);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or default preferences nodes.

	 * @param key

	 * @return

	 */

		return this.getEditorInput().getResult().getDoubleParameterValue(key);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or default preferences nodes.

	 * @param key

	 * @return

	 */

		return this.getEditorInput().getResult().getBooleanParameterValue(key);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or default preferences nodes.

	 * @param key

	 * @return

	 */

		return this.getEditorInput().getResult().getLongParameterValue(key);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or default preferences nodes.

	 * @param key

	 * @return

	 */

		return this.getEditorInput().getResult().getStringParameterValue(key);

	}

	// FIXME: SJ: tests to enable/disable when computing

	// FIXME: SJ: tests to enable/disable when computing

	/**

	 * Computes the TXMResult if all required parameters are set then refreshes the editor UI.

	 * @param result

	 * @param update force the editor to update its result parameters

	 */

		StatusLine.setMessage(TXMCoreMessages.bind(TXMUIMessages.computing, this.getResult().getName()));

		JobHandler job = new JobHandler(TXMCoreMessages.bind(TXMUIMessages.computing, this.getResult().getName())) {

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				this.runInit(monitor);

				try {

					JobsTimer.start();

					// FIXME: SJ: tests

					this.syncExec(new Runnable() {

						@Override

						public void run() {

							// FIXME: SJ: tests to enable/disable the editor widgets when computing

								// popup alert to inform user that the result has been manually edited

								if (TXMEditor.this.getResult().isAltered()

									setCanceled(true);

								}

								// popup alert to inform user that children results will be recomputed

									setCanceled(true);

								}

								// subclasses manual result updating from editor fields

								Log.finer("TXMEditor.compute(): " + TXMEditor.this.getClass().getSimpleName() + ": manually updating result from editor."); //$NON-NLS-1$

								updateResultFromEditor();

								// auto updating result parameters from parameter annotations of editor

								Log.finer("TXMEditor.compute(): " + TXMEditor.this.getClass().getSimpleName() + ": auto updating result from editor."); //$NON-NLS-1$

								autoUpdateResultFromEditorParameters();

								// FIXME: SJ: useless at this time?

							}

							// FIXME: SJ: there is a bug when deleting LT lines for example, the popup alert to inform user that children results will be recomputed is not triggered

							//

						}

					});

					// computing result

					monitor.beginTask(TXMUIMessages.computing_3, 100);

					// user log info

					if (update && TXMEditor.this.getResult().canCompute() && !TXMEditor.this.getResult().getComputingStartMessage().isEmpty()) {

						Log.info(TXMEditor.this.getResult().getComputingStartMessage());

						Log.fine("TXMEditor.compute(): " + TXMEditor.this.getClass().getSimpleName() + ": computing failed.");

					}

					// user log info

						Log.info(TXMEditor.this.getResult().getComputingDoneMessage());

					}

					notifyExtensions("notifyEndOfCompute"); //$NON-NLS-1$

					monitor.worked(50);

					// refreshing the UI

					this.syncExec(new Runnable() {

						@Override

						public void run() {

							try {

								refresh(update);

								setFocus();

								StatusLine.setMessage(null);

								// FIXME: SJ: tests to enable/disable the editor widgets when computing

								Log.finer("TXMEditor.compute(): " + TXMEditor.this.getClass().getSimpleName() + ": Error while refreshing the editor: " + e); //$NON-NLS-1$

								Log.printStackTrace(e);

							}

		};

		job.setPriority(Job.DECORATE);

		// FIXME: SJ tests

		job.setUser(true);

		job.schedule();

		return job;

	}

	/**

	 * Opens an editor specified by its id, computes the specified result then refreshes the editor components.

	 * If the editor was already opened, the computing is skipped and the focus is given to the editor.

	 * @param result

	 * @param editorPartId

	 */

		return openEditor(new TXMResultEditorInput<TXMResult>(result), editorPartId);

	}

	/**

	 * Opens an editor specified by its id, computes the result stored in the specified editor input then refreshes the editor components.

	 * If the editor was already opened, the computing is skipped and the focus is given to the editor.

	 * @param editorInput

	 * @param editorId

	 * @return

	 */

	@SuppressWarnings("unchecked")

		TXMEditor<? extends TXMResult> editor = null;

		IWorkbenchWindow window = TXMWindows.getActiveWindow();

		IWorkbenchPage page = window.getActivePage();

			else {

				return null;

			}

			if (wasAlreadyOpened) {

				// compute the result only if the editor wasn't already opened

					editor.compute(false);

					editor.refresh(false);

				}

			}

		}

		return editor;

	}

	/**

	 * Synchronizes the editor from the result and refreshes the corpus view.

	 * Also fires a dirty property change.

	 * @param update

	 */

	public final void refresh(boolean update) throws Exception {

		if (this.parent.isDisposed()) return; // nothing to refresh

		// skip refresh if the part creation has failed

		this.notifyExtensions("notifyStartOfRefresh"); //$NON-NLS-1$

		TXMResult result = this.getResult();

		// disable the component rendering to avoid strange behaviors when modifying the result area widget

		String title = result.getName();

		if (title.length() > 41) { // limit title length

		}

		this.setPartName(title);

		// SJ need to check all works, it also was dedicated to not refresh the Editor from result after a computing, it's not needed since the computing has been done

		// from fields themselves

		// FIXME: debug

		Log.finest("TXMEditor.refresh(): " + this.getClass().getSimpleName() + ": auto updating editor from result."); //$NON-NLS-1$

		this.autoUpdateEditorFieldsFromResult(update); // auto update from Parameter annotations

		// FIXME: debug

		Log.finest("TXMEditor.refresh(): " + this.getClass().getSimpleName() + ": updating subclass editor from result."); //$NON-NLS-1$ //$NON-NLS-2$

		this.updateEditorFromResult(update); // subclasses manual settings

		// Hide the computing parameter area if the editor wasn't open and the result is computed

		if (!update && !result.isDirty() && !this.topToolBar.isDisposed()) {

			this.topToolBar.setComputingParametersVisible(false);

		}

		if (!topToolBar.isDisposed()) this.topToolBar.redraw();

		CorporaView.refreshObject(this);

		TXMResultDebugView.refreshView();

		// re-enable the component rendering

		this.getContainer().setRedraw(true);

		// FIXME: SJ: this code breaks the dirty/chart dirty separation state, eg. if a non electric rendering parameter is changed then the chart is dirty but not the result, need to check this

		this.setDirty(this.getResult().isDirty());

		// FIXME: update all open editors of the children result but also of the result itself

		// FIXME: debug

		Log.finest("TXMEditor.refresh(): " + this.getClass().getSimpleName() + ": synchronizing and refreshing result children opened editors."); //$NON-NLS-1$ //$NON-NLS-2$

		List<TXMResult> results = this.getResult().getDeepChildren();

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

			for (int j = 0; j < editors.size(); j++) {

				ITXMResultEditor<?> txmEditor = editors.get(j);

					// FIXME: SJ: need to prove/test this code

					txmEditor.refresh(true);

				}

			}

		}

		this.notifyExtensions("notifyEndOfRefresh"); //$NON-NLS-1$

		// re-enable the rendering that has been disabled in createPartControl()

		// FIXME: SJ: would be very nice to do that to avoid to see the empty tables before the refresh() that fill the UI.

		// the disabling is done in createPartControl() but the EditionEditor doesn't seem to call refresh() so it breaks it

	}

	/**

	 * Synchronizes the result parameters with editor widgets.

	 * <p>

	 * It should be called or called itself in the UI thread when accessing Widget parameters.

	 */

	public abstract void updateResultFromEditor();

	/**

	 * Dedicated to dynamically change the editor components from the stored result.

	 * 

	 * Use this method if you need to save parameter with Type not managed by the autoUpdateEditorFieldsFromResult method.

	 */

	public abstract void updateEditorFromResult(boolean update) throws Exception;

	/**

	 * Updates the editor fields from TXMResult and declared parameters annotations in both TXMEditor and TXMResult.

	 * Manages these widgets at this moment:

	 * Button (Boolean)

	 * Viewer (Object)

	 * PropertiesSelector (Property and List<Property>)

	 * QueryWidget (String, from Query)

	 * 

	 */

		List<Field> fields = this.getAllParameterFields();

		for (Field f : fields) {

			Parameter parameter = f.getAnnotation(Parameter.class);

			if (parameter == null || parameter.key().isEmpty()) {

				continue;

			}

			Object object = null;

			Object value = null;

			try {

				f.setAccessible(true);

				object = f.get(this);

				// propagate to all parents

				value = this.getResult().getParameter(parameter.key(), true);

				if (value == null) {

					continue; // not initialized

				}

				}

					}

					else {

					}

				}

				}

				}