EDIT

/**

 * Copyright (C) 2007 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.editor.name.e4.container;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.apache.commons.lang3.StringUtils;

import org.eclipse.core.runtime.Assert;

import org.eclipse.e4.ui.di.UISynchronize;

import org.eclipse.jface.dialogs.Dialog;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.Position;

import org.eclipse.jface.window.DefaultToolTip;

import org.eclipse.swt.custom.StyledText;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.DragSource;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.events.ControlAdapter;

import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.events.ControlListener;

import org.eclipse.swt.events.FocusAdapter;

import org.eclipse.swt.events.FocusEvent;

import org.eclipse.swt.events.FocusListener;

import org.eclipse.swt.events.ModifyEvent;

import org.eclipse.swt.events.ModifyListener;

import org.eclipse.swt.events.MouseAdapter;

import org.eclipse.swt.events.MouseEvent;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Font;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Label;

import org.eclipse.ui.forms.IFormPart;

import org.eclipse.ui.forms.IManagedForm;

import org.eclipse.ui.forms.widgets.TableWrapData;

import org.eclipse.ui.forms.widgets.TableWrapLayout;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.name.TaxonName;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

import eu.etaxonomy.cdm.strategy.parser.ParserProblem;

import eu.etaxonomy.taxeditor.editor.CdmDataTransfer;

import eu.etaxonomy.taxeditor.editor.l10n.Messages;

import eu.etaxonomy.taxeditor.editor.name.container.EditorAnnotation;

import eu.etaxonomy.taxeditor.editor.name.container.EditorAnnotation.EditorAnnotationType;

import eu.etaxonomy.taxeditor.editor.name.container.IContainerConstants;

import eu.etaxonomy.taxeditor.editor.name.container.LineBreakListener;

import eu.etaxonomy.taxeditor.editor.name.container.LineWrapSupport;

import eu.etaxonomy.taxeditor.editor.name.e4.TaxonEditor;

import eu.etaxonomy.taxeditor.editor.name.e4.dnd.NameEditorDragListenerE4;

import eu.etaxonomy.taxeditor.editor.name.e4.dnd.NameEditorDragSourceEffect;

import eu.etaxonomy.taxeditor.editor.name.operation.CreateSynonymInNewGroupOperation;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.IElementHasDetails;

import eu.etaxonomy.taxeditor.model.NameHelper;

import eu.etaxonomy.taxeditor.model.TextHelper;

import eu.etaxonomy.taxeditor.parser.ParseHandler;

import eu.etaxonomy.taxeditor.preference.Resources;

/**

 * Formats <code>GroupedComposite</code> with cosmetic and layout properties

 * specific to the Editor. This should be used to maintain a consistent look and

 * feel for all Editor freetext area components, such as

 * DescriptionElementComposite.

 * <p>

 * Requires an <code>IManagedForm</code>, whose <code>input</code> is set to the

 * contents of {@link #getData()} when the <code>GroupedComposite</code> gets

 * focus, i.e. to populate the property sheet with the data.

 * </p>

 * <p>

 * The <code>IManagedForm</code> is also required to have a <code>Taxon</code>

 * in its own <code>getData()</code>.

 * </p>

 * <p>

 * The <code>IManagedForm</code> can also used for drawing borders by calling

 * the method <code>createBorderSupport()</code>.

 * </p>

 * @author pplitzner

 * @date Aug 24, 2017

 *

 * @param <T>

 */

abstract public class AbstractGroupedContainer<T extends TaxonBase> implements

		IFormPart, IContainerConstants, IElementHasDetails {

	protected ParseHandler parseHandler;

	private FocusListener nameCompositeFocusListener;

	private ModifyListener nameCompositeModifyListener;

	protected NameViewer nameViewer;

	private AbstractGroup group;

	private Label nonEditableInfoLabel;

	private DefaultToolTip nonEditableInfoHover;

	private static AbstractGroupedContainer<?> selection;

	private FocusListener focusListener;

	private LineBreakListener lineBreakListener;

	private int cursorPosition;

	protected Composite control;

	private Color backgroundColor;

	private boolean isDirty;

	public AbstractGroupedContainer(AbstractGroup group, T taxonBase) {

		setData(taxonBase);

		this.group = group;

		parseHandler = ParseHandler.NewInstance(taxonBase.getName());

	}

	public void createContent() {

		createControl();

		createTextViewer();

		createLineWrapSupport();

		createLineBreakListener();

		setMenu();

		setDraggableControl(new Control[] { getControl(),

				getNameViewer().getRulerControl() });

		createEmptyViewerPrompt(EMPTY_NAME_PROMPT);

		initializeComposite();

		createListener();

		enableFreeText();

	}

	protected void createListener() {

		nameCompositeModifyListener = (ModifyEvent e)->{

				// mark the composite dirty

				setDirty(true);

				// parse the text

				String text = nameViewer.getTextWidget().getText();

				TaxonName name = (TaxonName)parseHandler.parse(text);

				getTaxonBase().setName(name);

				getTaxonBase().setTitleCache((getTaxonBase().generateTitle()));

//				EventUtility.postAsyncEvent(WorkbenchEventConstants.REFRESH_DETAILS, true);

				// show errors resulting from parsing

				calculateAnnotations();

				// store the position of the cursor

				storeCursor();

				// notify selection listener

				setDelayedSelection();

		};

		nameCompositeFocusListener = new FocusAdapter() {

			@Override

			public void focusLost(FocusEvent e) {

				super.focusLost(e);

				persistName();

			}

		};

		addListener();

	}

	protected void addListener() {

		getNameViewer().getTextWidget().addModifyListener(

				nameCompositeModifyListener);

		getNameViewer().getTextWidget().addFocusListener(

				nameCompositeFocusListener);

	}

	protected void removeListener() {

		getNameViewer().getTextWidget().removeModifyListener(

				nameCompositeModifyListener);

		getNameViewer().getTextWidget().removeFocusListener(

				nameCompositeFocusListener);

	}

	/**

	 * Initialize the composite specific code

	 */

	protected abstract void initializeComposite();

	protected String getEmptyTextPrompt() {

		return EMPTY_NAME_PROMPT;

	}

	protected void initTextViewer() {

		updateIndent();

		updateIcon();

		String text = NameHelper.getDisplayNameWithRef(getData());

		if (text.length() == 0) {

			initEmptyText();

		} else {

			getNameViewer().setText(text);

			placeCursor();

		}

		calculateAnnotations();

	}

	synchronized protected void calculateAnnotations() {

		getNameViewer().clearAnnotations();

		showAnnotations();

	}

	public void showAnnotations() {

		if (getName() != null && getName().hasProblem()) {

			showParsingProblems();

		}

		if (!isNameParsable()) {

			getNameViewer()

					.addAnnotation(

							new EditorAnnotation(EditorAnnotationType.WARNING,

									0,

									Messages.AbstractGroupedContainer_EDIT_IN_DETAILS_VIEW));

		}

		if (isNameUsedMultipleTimes()) {

			getNameViewer().addAnnotation(

					new EditorAnnotation(EditorAnnotationType.WARNING, 0,

							Messages.AbstractGroupedContainer_MULTIPLE_USE));

		}

	}

	private void showParsingProblems() {

		TaxonName name = getName();

		if (name == null){

			return;

		}

		List<ParserProblem> parsingProblems = name.getParsingProblems();

		for (ParserProblem problem : parsingProblems) {

			getNameViewer().addAnnotation(new EditorAnnotation(problem),

					getParsingProblemPosition());

		}

	}

	private Position getParsingProblemPosition() {

		String text = getNameViewer().getTextWidget().getText();

		if (getName() != null && getName().hasProblem() && text.length() > 0) {

			int start = getName().getProblemStarts();

			int length = getName().getProblemEnds() - start;

			if (start == -1 || getName().getProblemEnds() == -1) {

				return null;

			}

			// Don't let squigglies try to draw beyond the end of the text

			if (text.length() < start + length) {

				length = text.length() - start;

			}

			if (length<0){

				return null;

			}

			return new Position(start, length);

		}

		return null;

	}

	protected void handleSplitText(String text) {

		// Create a synonym in a new homotypic group using text as name

		TaxonName synonymName = TaxonName.castAndDeproxy(

				ParseHandler.parseReferencedName(text, null));

		AbstractUtility.executeOperation(new CreateSynonymInNewGroupOperation(

				Messages.AbstractGroupedContainer_NEW_HETERO_SYNONYM, getEditor().getUndoContext(),

				getEditor().getTaxon(), synonymName, getEditor()), group.getContext().get(UISynchronize.class));

	}

	/**

	 * Refreshes the display with latest data from the model.

	 *

	 * Note: Will not parse the text and not calculate errors!

	 */

	@Override

    public void refresh() {

		// showNameRelations();

		String text = NameHelper.getDisplayNameWithRef(getTaxonBase());

		if (getNameViewer().getTextWidget() == null) {

			// we might get here via dnd. Look slike it can be ignored

			return;

		}

		if (text.length() == 0) {

			initEmptyText();

		} else if (!getNameViewer().getTextWidget().getText().equals(text)) {

			removeListener();

			getNameViewer().getTextWidget().setText(text);

			addListener();

		}

		updateNonEditableInfo();

		updateIcon();

		// placeCursor();

		updateIndent();

		setDelayedSelection();

		enableFreeText();

	}

	protected abstract void updateIcon();

	protected abstract void updateIndent();

	protected abstract void updateNonEditableInfo();

	protected void enableFreeText() {

		setEnabled(isFreetextEditingAllowed());

	}

	/**

	 * Checks whether the freetext should be editable based on specific empty

	 * fields.

	 *

	 * @return

	 */

	private boolean isFreetextEditingAllowed() {

		boolean enableFreetext = true;

		enableFreetext |= isNameUsedMultipleTimes();

		enableFreetext &= isNameParsable();

		return enableFreetext;

	}

	/**

	 * Checks whether there are more than one, non-orphaned taxon bases

	 * attached to the taxon name

	 *

	 * @return

	 */

	private boolean isNameUsedMultipleTimes() {

		TaxonName name = getName();

		if (name != null){

			Set<TaxonBase> taxonBases = name.getTaxonBases();

			Iterator<TaxonBase> tbItr = taxonBases.iterator();

			int nonOrphanedTaxonBaseCount = taxonBases.size();

			while(tbItr.hasNext()) {

				TaxonBase<?> tb = tbItr.next();

				if(tb.isOrphaned()) {

					nonOrphanedTaxonBaseCount--;

				}

			}

			if(nonOrphanedTaxonBaseCount > 1) {

				return true;

			}

		}

		return false;

	}

	private boolean isNameParsable() {

		TaxonName name = getName();

		if (name == null){

			return false;

		}

		boolean isParsable = true;

		isParsable &= StringUtils.isBlank(name.getAppendedPhrase()); // taxonFieldsEmpty();

        if (name.isProtectedAuthorshipCache()){

            isParsable &= nameAuthorsSet(name);

        }

        if (name.isProtectedNameCache()){

            isParsable &= nameEpithetsNotSet(name) && nameAuthorsSet(name);

        }

		return isParsable;

	}

    private boolean nameAuthorsSet(TaxonName name) {

       boolean result = true;

       result &= name.getBasionymAuthorship() == null && name.getCombinationAuthorship() == null && name.getExBasionymAuthorship() == null && name.getExCombinationAuthorship() == null;

       return result;

    }

    private boolean nameEpithetsNotSet(TaxonName name) {

        boolean result = true;

        result &= name.getGenusOrUninomial() == null && name.getInfraGenericEpithet() == null && name.getSpecificEpithet() == null && name.getInfraSpecificEpithet() == null;

        return result;

    }

    /**

	 * Parse the text and calculate errors

	 */

	public void parseAndCalculateAnnotations() {

		removeListener();

		String unparsedNameString = getNameViewer().getTextWidget().getText();

		parseHandler.parse(unparsedNameString);

		addListener();

		calculateAnnotations();

	}

	public T getTaxonBase() {

		return getData();

	}

	public TaxonName getName() {

		return CdmBase.deproxy(getTaxonBase().getName());

	}

	public void persistName() {

		if (isDirty()) {

			getNameViewer().getTextWidget().setEnabled(false);

			final String unparsedNameString = getNameViewer().getTextWidget()

					.getText();

			final TaxonName name = (TaxonName)parseHandler

					.parseAndResolveDuplicates(unparsedNameString);

			getTaxonBase().setName(name);

			getTaxonBase().setTitleCache((getTaxonBase().generateTitle()));

			setDirty(false);

			getNameViewer().getTextWidget().setEnabled(true);

		}

	}

	public AbstractGroup getGroup() {

		if (group == null) {

			throw new IllegalStateException("Group shall not be null."); //$NON-NLS-1$

		}

		return group;

	}

	public void remove() {

		getGroup().remove(this);

	}

	protected void createControl() {

		control = getEditor().getToolkit().createComposite(

				getGroup().getControl());

		control.setLayoutData(new TableWrapData(TableWrapData.FILL_GRAB));

		TableWrapLayout layout = new TableWrapLayout();

		layout.leftMargin = 0;

		layout.rightMargin = 0;

		layout.topMargin = 5;

		layout.bottomMargin = 5;

		layout.verticalSpacing = 0;

		layout.horizontalSpacing = 0;

		control.setLayout(layout);

	}

	protected TaxonEditor getEditor() {

		return getGroup().getEditor();

	}

	public Composite getControl() {

		return control;

	}

	protected void createLineWrapSupport() {

		new LineWrapSupport(getNameViewer(), getEditor().getManagedForm());

	}

	protected void createTextViewer() {

		nameViewer = new NameViewer(control);

		focusListener = new FocusAdapter() {

			@Override

			public void focusGained(FocusEvent e) {

			    if (getEditor()

                        .getGroupedContainers().isEmpty()){

			        return;

			    }

				for (AbstractGroupedContainer<?> container : getEditor()

						.getGroupedContainers()) {

					container.colorSelected(NOT_SELECTED);

				}

				getEditor().getManagedForm().setInput(

						AbstractGroupedContainer.this);

				placeCursor();

				colorSelected(SELECTED_FOCUS);

			}

		};

		nameViewer.getTextWidget().addFocusListener(focusListener);

		MouseAdapter mouseListener = new MouseAdapter() {

			@Override

			public void mouseDown(MouseEvent e) {

				storeCursor();

			}

		};

		control.addMouseListener(mouseListener);

		nameViewer.getRulerControl().addMouseListener(mouseListener);

		nameViewer.getTextWidget().addMouseListener(mouseListener);

	}

	public void setIcon(Image icon) {

		getNameViewer().setIcon(icon);

	}

	public void setIndent(int indent) {

		if (control.getLayout() instanceof TableWrapLayout) {

			TableWrapLayout layout = ((TableWrapLayout) control.getLayout());

			layout.leftMargin = indent;

			layout.rightMargin = ACCEPTED_INDENT;

			control.setLayout(layout);

			control.layout();

		} else {

			throw new RuntimeException(

					"Couldn't indent - composite's layout must be TableWrapLayout."); //$NON-NLS-1$

		}

	}

	public void setSelected() {

		getNameViewer().getTextWidget().setFocus();

	}

	public boolean isSelected() {

		return getEditor().getSelectedContainer() == this;

	}

	public void colorSelected(int mode) {

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

			String colorString = null;

			switch (mode) {

			case SELECTED_FOCUS:

				colorString = Resources.COLOR_CONTROL_SELECTED_FOCUS;

				break;

			case SELECTED_NO_FOCUS:

				colorString = Resources.COLOR_CONTROL_SELECTED;

				break;

			default:

				colorString = Resources.COLOR_COMPOSITE_BACKGROUND;

			}

			backgroundColor = AbstractUtility.getColor(colorString);

			setBackground(backgroundColor);

		}

	}

	private Delay delay = new Delay(Display.getCurrent());

	private class Delay extends Thread{

	    private volatile boolean stop = false;

        private Display display;

        public Delay(Display display) {

            this.display = display;

        }

        @Override

        public void run() {

            while (!stop) {

                try {

                    // my code goes here

                    Thread.sleep(1000);

                    if(!stop){

                        display.syncExec(() -> {

                                getEditor().getManagedForm().setInput(selection);

                        });

                        stop = true;

                    }

                } catch (InterruptedException ex) {

                    stop = true;

                }

            }

        }

        public void requestStop() {

            stop = true;

        }

	}

	protected void setDelayedSelection() {

		selection = this;

		Display display = Display.getCurrent();

		delay.requestStop();

		delay = new Delay(display);

		delay.start();

	}

	public void setBackground(Color color) {

		control.setBackground(color);

		for (Control child : control.getChildren()) {

			child.setBackground(color);

		}

		getNameViewer().setBackground(color);

	}

	public void setFont(Font font) {

		getNameViewer().getTextWidget().setFont(font);

	}

	public NameViewer getNameViewer() {

		if (nameViewer == null) {

			throw new RuntimeException(

					"The Name Viewer is corrupt for Name Container: " //$NON-NLS-1$

							+ getTaxonBase().getName().getTitleCache());

		}

		return nameViewer;

	}

	public void createEmptyViewerPrompt(final String prompt) {

		Assert.isNotNull(getNameViewer());

		final StyledText textControl = getNameViewer().getTextWidget();

		final IDocument document = getNameViewer().getDocument();

		setFocusListener(new FocusListener() {

			@Override

            public void focusGained(FocusEvent e) {

				if (document.get().equals(prompt)) {

					textControl.setFont(getViewerFont());

					document.set(""); //$NON-NLS-1$

				}

			}

			@Override

            public void focusLost(FocusEvent e) {

				if (document.getLength() == 0) {

					initEmptyText();

				}

			}

		});

		textControl.addFocusListener(getFocusListener());

		if (document.getLength() == 0) {

			textControl.setFont(AbstractUtility

					.getFont(Resources.FONT_DEFAULT_PROMPT));

			document.set(prompt);

		}

	}

	abstract protected Font getViewerFont();

	protected void initEmptyText() {

		Font defaultFont = AbstractUtility.getFont(Resources.FONT_DEFAULT_PROMPT);

		getNameViewer().getTextWidget().setFont(defaultFont);

		getNameViewer().getDocument().set(getEmptyTextPrompt());

	}

	protected void setFocusListener(FocusListener focusListener) {

		this.focusListener = focusListener;

	}

	private FocusListener getFocusListener() {

		return focusListener;

	}

	public void setDirty(boolean isDirty) {

		if (isDirty) {

			getEditor().getManagedForm().dirtyStateChanged();

		}

		this.isDirty = isDirty;

	}

	@Override

    public boolean isDirty() {

		return isDirty;

	}

	public void setMenu() {

        getEditor().getMenuService().registerContextMenu(getNameViewer().getTextWidget(), "eu.etaxonomy.taxeditor.editor.popupmenu.nameeditor");

	}

	private Control[] draggableControls;

	protected void setDraggableControl(Control[] controls) {

		draggableControls = controls;

	}

	public void setIsDraggable(boolean draggable) {

		if (draggable) {

			if (draggableControls == null) {

				throw new NullPointerException(

						"Draggable controls must be set to add draggability"); //$NON-NLS-1$

			}

			Transfer[] types = new Transfer[] { CdmDataTransfer.getInstance() };

			int operations = DND.DROP_MOVE;

			for (Control draggableControl : draggableControls) {

				DragSource dragSource = new DragSource(draggableControl,

						operations);

				dragSource.setTransfer(types);

				dragSource.addDragListener(new NameEditorDragListenerE4(this));

				dragSource.setDragSourceEffect(new NameEditorDragSourceEffect(

						control));

			}

		}

	}

	private String nonEditableText;

	ControlListener nonEditableResizeListener = new ControlAdapter() {

		int width = 0;

		@Override

		public void controlResized(ControlEvent e) {

			if (nonEditableInfoLabel.getBounds().width == width) {

				return;

			}

			width = nonEditableInfoLabel.getBounds().width;

			if (nonEditableInfoLabel.getBounds().width > 0) {

				nonEditableInfoLabel.setText(Dialog.shortenText(

						nonEditableText.toUpperCase(), nonEditableInfoLabel));

			}

		}

	};

	private String nonEditableHoverText;

	private LabelEllipsisListener nonEditableLabelEllipsisListener;

	private T data;

	/**

	 * nonEditableInfo is a label displayed underneath a GroupedComposite's

	 * input field. For instance, NameComposites display things like name

	 * relations, sec. references, etc. here.

	 *

	 * @param info

	 *            the text to display in the label

	 * @param append

	 *            whether the string should be appended to text that is already

	 *            shown in the label

	 */

	public void setNonEditableInfo(String info, boolean append) {

		// TODO non editable info should only be drawn once, when everything

		// else is drawn

		info = info.toUpperCase();

		if (append) {

			nonEditableText += ", " + info; //$NON-NLS-1$

			nonEditableHoverText += "\n" + info; //$NON-NLS-1$

		} else {

			nonEditableText = info;

			nonEditableHoverText = info;

		}

		if (nonEditableInfoLabel == null) {

			nonEditableInfoLabel = getEditor().getToolkit().createLabel(

					control, ""); //$NON-NLS-1$

			TableWrapData layoutData = new TableWrapData(

					TableWrapData.FILL_GRAB, TableWrapData.TOP);

			// Set indent to viewer ruler's width

			if (getNameViewer().getRulerControl() != null) {

				// TODO right justify

				layoutData.indent = NameViewer.RULER_WIDTH;

			}

			nonEditableInfoLabel.setLayoutData(layoutData);

			nonEditableLabelEllipsisListener = new LabelEllipsisListener(

					nonEditableInfoLabel) {

				@Override

				public String getLabelText() {

					return nonEditableText.toUpperCase();

				}

			};

			nonEditableInfoLabel

					.addControlListener(nonEditableLabelEllipsisListener);

			nonEditableInfoHover = new DefaultToolTip(nonEditableInfoLabel);

			nonEditableInfoHover.setRespectDisplayBounds(true);

		}

		nonEditableInfoHover.setText(nonEditableHoverText);

		nonEditableInfoLabel.setText(nonEditableText);

		calculateAnnotations();

	}

	@Override

    public T getData() {

		return data;

	}

	public void setData(T data) {

		this.data = HibernateProxyHelper.deproxy(data);

	}

	/**

	 * If the user hitting carriage return should cause something to happen -

	 * i.e. the creation of a new composite - call this method and override the

	 * method handleSplitText().

	 */

	protected void createLineBreakListener() {

		lineBreakListener = new LineBreakListener() {

			@Override

			public void handleSplitText(String text) {

				AbstractGroupedContainer.this.handleSplitText(text);

			}

		};

		getNameViewer().getTextWidget().addVerifyListener(lineBreakListener);

	}

	abstract class LabelEllipsisListener extends ControlAdapter {

		private final Label label;

		int width = 0;

		LabelEllipsisListener(Label label) {

			this.label = label;

		}

		abstract public String getLabelText();

		@Override

		public void controlResized(ControlEvent e) {

			if (label.getBounds().width == width) {

				return;

			}

			width = label.getBounds().width;

			if (label.getBounds().width > 0) {

				label.setText(TextHelper.shortenText(getLabelText(), label));

			}

		}

	}

	public void storeCursor() {

		this.cursorPosition = getNameViewer().getCursorPosition();

	}

	/**

	 * Puts the cursor to the position it was last seen on or to the end of line

	 * if no former position is known.

	 */

	public void placeCursor() {

		if (cursorPosition == 0) {

			getNameViewer().setCursorToEOL();

		} else {

			getNameViewer().setCursorPosition(cursorPosition);

		}

	}

	public void restoreColor() {

		setBackground(backgroundColor);

	}

	@Override

	public void initialize(IManagedForm form) {

		// TODO Auto-generated method stub

	}

	@Override

	public void dispose() {

		if (getControl() != null) {

			getControl().dispose();

		}

	}

	@Override

	public void commit(boolean onSave) {

		if (isDirty()) {

			persistName();

		}

	}

	@Override

	public boolean setFormInput(Object input) {

		return false;

	}

	@Override

	public void setFocus() {

		getNameViewer().getControl().setFocus();

	}

	@Override

	public boolean isStale() {

		return false;

	}

	public void setDisabled(boolean disabled) {

		setEnabled(!disabled);

	}

	public void setEnabled(boolean enabled) {

		Color color = enabled ? control.getForeground() : AbstractUtility.getColor(Resources.COLOR_DISABLED_EDITOR);

		getNameViewer().getTextWidget().setEditable(enabled);

		getNameViewer().getTextWidget().setForeground(color);

	}