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.container;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.eclipse.core.runtime.Assert;

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.KeyEvent;

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.swt.widgets.Menu;

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.common.CdmUtils;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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

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

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.EditorUtil;

import eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor;

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

import eu.etaxonomy.taxeditor.editor.name.dnd.NameEditorDragListener;

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

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

import eu.etaxonomy.taxeditor.labels.ILabelImageStrategy;

import eu.etaxonomy.taxeditor.labels.LabelImageProvider;

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 p.ciardelli

 * @author n.hoffmann

 * @created 02.06.2008

 * @version 1.0

 */

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;

	/**

	 * <p>

	 * Constructor for AbstractGroupedContainer.

	 * </p>

	 * 

	 * @param editor

	 *            a {@link eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor}

	 *            object.

	 * @param group

	 *            a

	 *            {@link eu.etaxonomy.taxeditor.editor.name.container.AbstractGroup}

	 *            object.

	 * @param taxonBase

	 *            a T object.

	 * @param <T>

	 *            a T object.

	 */

	public AbstractGroupedContainer(T taxonBase) {

		setData(taxonBase);

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

	}

	public void createContent() {

		createControl();

		createTextViewer();

		createLineWrapSupport();

		createLineBreakListener();

		setMenu(getEditor().getMenu());

		setDraggableControl(new Control[] { getControl(),

				getNameViewer().getRulerControl() });

		createEmptyViewerPrompt(EMPTY_NAME_PROMPT);

		initializeComposite();

		createListener();

		enableFreeText();

	}

	/**

	 * <p>

	 * createListener

	 * </p>

	 */

	protected void createListener() {

		nameCompositeModifyListener = new ModifyListener() {

			public void modifyText(ModifyEvent e) {

				// mark the composite dirty

				setDirty(true);

				// parse the text

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

				TaxonNameBase<?,?> name = (TaxonNameBase<?,?>)parseHandler.parse(text);

				getTaxonBase().setName(name);

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

				// show errors resulting from parsing

				calculateAnnotations();

				// store the position of the cursor

				storeCursor();

				// notify selection listener

				setDelayedSelection();

			}

		};

		nameCompositeFocusListener = new FocusAdapter() {

			/*

			 * (non-Javadoc)

			 * 

			 * @see

			 * org.eclipse.swt.events.FocusAdapter#focusLost(org.eclipse.swt

			 * .events.FocusEvent)

			 */

			@Override

			public void focusLost(FocusEvent e) {

				super.focusLost(e);

				persistName();

			}

		};

		addListener();

	}

	private void addListener() {

		getNameViewer().getTextWidget().addModifyListener(

				nameCompositeModifyListener);

		getNameViewer().getTextWidget().addFocusListener(

				nameCompositeFocusListener);

	}

	private void removeListener() {

		getNameViewer().getTextWidget().removeModifyListener(

				nameCompositeModifyListener);

		getNameViewer().getTextWidget().removeFocusListener(

				nameCompositeFocusListener);

	}

	/**

	 * Initialize the composite specific code

	 */

	protected abstract void initializeComposite();

	/**

	 * <p>

	 * getEmptyTextPrompt

	 * </p>

	 * 

	 * @return a {@link java.lang.String} object.

	 */

	protected String getEmptyTextPrompt() {

		return EMPTY_NAME_PROMPT;

	}

	/**

	 * 

	 */

	private void showNameRelations() {

		TaxonNameBase<?, ?> name = getName();

		if (name == null) {

			return;

		}

		ILabelImageStrategy strategy = LabelImageProvider

				.getLabelStrategy(name);

		LabelImageProvider labelProvider = new LabelImageProvider(strategy);

		Set<NameRelationship> nameRelations = name.getNameRelations();

		if (nameRelations.size() == 0) {

			return;

		}

		// for (NameRelationship nameRelation : nameRelations) {

		// String typeLabel = null;

		// TaxonNameBase<?, ?> relatedName = null;

		//

		// if (name.equals(nameRelation.getFromName())) {

		// typeLabel = labelProvider.getNameRelationTypeLabel(

		// nameRelation.getType());

		// relatedName = nameRelation.getToName();

		// } else {

		// typeLabel = labelProvider.getNameRelationTypeInverseLabel(

		// nameRelation.getType());

		// relatedName = nameRelation.getFromName();

		// }

		//

		// setNonEditableInfo(typeLabel + " " +

		// NameHelper.getDisplayName(relatedName));

		// }

	}

	/**

	 * <p>

	 * initTextViewer

	 * </p>

	 */

	protected void initTextViewer() {

		// showNameRelations();

		updateIndent();

		updateIcon();

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

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

			initEmptyText();

		} else {

			getNameViewer().setText(text);

			placeCursor();

		}

		calculateAnnotations();

	}

	/**

	 * <p>

	 * calculateErrors

	 * </p>

	 */

	synchronized protected void calculateAnnotations() {

		getNameViewer().clearAnnotations();

		showAnnotations();

	}

	/**

	 * 

	 */

	public void showAnnotations() {

		if (getName().hasProblem()) {

			showParsingProblems();

		}

		if (!isNameParsable()) {

			getNameViewer()

					.addAnnotation(

							new EditorAnnotation(EditorAnnotationType.WARNING,

									0,

									"This name may only be edited in the details view."));

		}

		if (isNameUsedMultipleTimes()) {

			getNameViewer().addAnnotation(

					new EditorAnnotation(EditorAnnotationType.WARNING, 0,

							"This taxons name is used multiple times."));

		}

	}

	/**

	 * 

	 */

	private void showParsingProblems() {

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

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

		for (ParserProblem problem : parsingProblems) {

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

					getParsingProblemPosition());

		}

	}

	private Position getParsingProblemPosition() {

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

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

	}

	/**

	 * <p>

	 * handleSplitText

	 * </p>

	 * 

	 * @param text

	 *            a {@link java.lang.String} object.

	 */

	protected void handleSplitText(String text) {

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

		TaxonNameBase synonymName = ParseHandler

				.parseReferencedName(text, null);

		EditorUtil.executeOperation(new CreateSynonymInNewGroupOperation(

				"New Heterotypic Synonym", getEditor().getUndoContext(),

				getEditor().getTaxon(), synonymName, getEditor()));

	}

	/**

	 * Refreshes the display with latest data from the model.

	 * 

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

	 */

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

		enableFreeText();

	}

	/**

	 * 

	 */

	protected abstract void updateIcon();

	protected abstract void updateIndent();

	/**

	 * <p>

	 * updateNonEditableInfo

	 * </p>

	 */

	protected abstract void updateNonEditableInfo();

	/**

	 * 

	 */

	private void enableFreeText() {

		setEnabled(isFreetextEditingAllowed());

	}

	/**

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

	 * fields.

	 * 

	 * @return

	 */

	private boolean isFreetextEditingAllowed() {

		NonViralName name = (NonViralName) HibernateProxyHelper

				.deproxy(getName());

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

		Set<TaxonBase> taxonBases = getName().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() {

		TaxonNameBase name = getName();

		boolean isParsable = true;

		isParsable &= CdmUtils.isEmpty(name.getAppendedPhrase()); // taxonFieldsEmpty();

		if (name instanceof NonViralName) {

			NonViralName nonViralName = (NonViralName) name;

			isParsable &= !nonViralName.isProtectedAuthorshipCache();

			isParsable &= !nonViralName.isProtectedNameCache();

		}

		return isParsable;

	}

	/**

	 * Parse the text and calculate errors

	 */

	public void parseAndCalculateAnnotations() {

		removeListener();

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

		parseHandler.parse(unparsedNameString);

		addListener();

		calculateAnnotations();

	}

	/**

	 * <p>

	 * getTaxonBase

	 * </p>

	 * 

	 * @return the taxonBase

	 */

	public T getTaxonBase() {

		return getData();

	}

	/**

	 * <p>

	 * getName

	 * </p>

	 * 

	 * @return a {@link eu.etaxonomy.cdm.model.name.TaxonNameBase} object.

	 */

	public TaxonNameBase getName() {

		return (TaxonNameBase) HibernateProxyHelper.deproxy(getTaxonBase()

				.getName());

	}

	/**

	 * <p>

	 * persistName

	 * </p>

	 */

	public void persistName() {

		if (isDirty()) {

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

			final String unparsedNameString = getNameViewer().getTextWidget()

					.getText();

			// Job job = new Job("Persisting Name"){

			//

			// @Override

			// protected IStatus run(IProgressMonitor monitor) {

			//

			final TaxonNameBase<?,?> name = (TaxonNameBase<?,?>)parseHandler

					.parseAndResolveDuplicates(unparsedNameString);

			//

			// Display.getDefault().asyncExec(new Runnable(){

			// public void run() {

			getTaxonBase().setName(name);

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

			setDirty(false);

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

			// };

			// });

			//

			//

			// return Status.OK_STATUS;

			// }

			//

			// };

			//

			// job.setPriority(Job.DECORATE);

			// job.schedule();

		}

	}

	/**

	 * <p>

	 * Getter for the field <code>group</code>.

	 * </p>

	 * 

	 * @return a

	 *         {@link eu.etaxonomy.taxeditor.editor.name.container.AbstractGroup}

	 *         object.

	 */

	public AbstractGroup getGroup() {

		if (group == null) {

			throw new IllegalStateException("Group shall not be null.");

		}

		return group;

	}

	/**

	 * <p>

	 * remove

	 * </p>

	 */

	public void remove() {

		getGroup().remove(this);

	}

	/**

	 * <p>

	 * createControl

	 * </p>

	 */

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

	}

	/**

	 * @return

	 */

	protected TaxonNameEditor getEditor() {

		return getGroup().getEditor();

	}

	/**

	 * <p>

	 * Getter for the field <code>control</code>.

	 * </p>

	 * 

	 * @return a {@link org.eclipse.swt.widgets.Composite} object.

	 */

	public Composite getControl() {

		return control;

	}

	/**

	 * <p>

	 * createLineWrapSupport

	 * </p>

	 */

	protected void createLineWrapSupport() {

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

	}

	/**

	 * <p>

	 * createTextViewer

	 * </p>

	 */

	protected void createTextViewer() {

		nameViewer = new NameViewer(control);

		focusListener = new FocusAdapter() {

			@Override

			public void focusGained(FocusEvent e) {

				if(!enabled){

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

	}

	/**

	 * <p>

	 * setIcon

	 * </p>

	 * 

	 * @param icon

	 *            a {@link org.eclipse.swt.graphics.Image} object.

	 */

	public void setIcon(Image icon) {

		getNameViewer().setIcon(icon);

	}

	/**

	 * <p>

	 * setIndent

	 * </p>

	 * 

	 * @param indent

	 *            a int.

	 */

	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 {

			new RuntimeException(

					"Couldn't indent - composite's layout must be TableWrapLayout.");

		}

	}

	/**

	 * <p>

	 * setSelected

	 * </p>

	 */

	public void setSelected() {

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

	}

	/**

	 * <p>

	 * isSelected

	 * </p>

	 * 

	 * @return a boolean.

	 */

	public boolean isSelected() {

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

	}

	/**

	 * <p>

	 * colorSelected

	 * </p>

	 * 

	 * @param mode

	 *            a int.

	 */

	public void colorSelected(int mode) {

		if (!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 = EditorUtil.getColor(colorString);

			setBackground(backgroundColor);

		}

	}

	/**

	 * <p>

	 * setDelayedSelection

	 * </p>

	 */

	protected void setDelayedSelection() {

		// TODO this might be done better

		// this is the quickest solution i could come up with and it improves

		// performance

		// please reimplement if you know better.

		selection = this;

		// start timer

		Display display = Display.getCurrent();

		Runnable runnable = new Runnable() {

			public void run() {

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

			}

		};

		display.timerExec(1000, runnable);

	}

	/**

	 * <p>

	 * setBackground

	 * </p>

	 * 

	 * @param color

	 *            a {@link org.eclipse.swt.graphics.Color} object.

	 */

	public void setBackground(Color color) {

		control.setBackground(color);

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

			child.setBackground(color);

		}

		getNameViewer().setBackground(color);

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * org.eclipse.swt.widgets.Control#setFont(org.eclipse.swt.graphics.Font)

	 */

	/**

	 * <p>

	 * setFont

	 * </p>

	 * 

	 * @param font

	 *            a {@link org.eclipse.swt.graphics.Font} object.

	 */

	public void setFont(Font font) {

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

	}

	/**

	 * <p>

	 * Getter for the field <code>nameViewer</code>.

	 * </p>

	 * 

	 * @return a {@link eu.etaxonomy.taxeditor.editor.name.container.NameViewer}

	 *         object.

	 */

	public NameViewer getNameViewer() {

		if (nameViewer == null) {

			throw new RuntimeException(

					"The Name Viewer is corrupt for Name Container: "

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

		}

		return nameViewer;

	}

	/**

	 * If <code>textViewer</code> has already been set, it will show a

	 * <code>prompt</code> along the lines of

	 * "Click here to start entering data" when empty.

	 * 

	 * @param prompt

	 *            a {@link java.lang.String} object.

	 */

	public void createEmptyViewerPrompt(final String prompt) {

		Assert.isNotNull(getNameViewer());

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

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

		setFocusListener(new FocusListener() {

			public void focusGained(FocusEvent e) {

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

					textControl.setFont(getViewerFont());

					document.set("");

				}

			}

			public void focusLost(FocusEvent e) {

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

					initEmptyText();

				}

			}

		});

		textControl.addFocusListener(getFocusListener());

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

			textControl.setFont(EditorUtil

					.getFont(Resources.FONT_DEFAULT_PROMPT));

			document.set(prompt);

		}

	}

	/**

	 * <p>

	 * getViewerFont

	 * </p>

	 * 

	 * @return a {@link org.eclipse.swt.graphics.Font} object.

	 */

	abstract protected Font getViewerFont();

	/**

	 * <p>

	 * initEmptyText

	 * </p>

	 */

	protected void initEmptyText() {

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

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

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

		placeCursor();

	}

	/**

	 * <p>

	 * Setter for the field <code>focusListener</code>.

	 * </p>

	 * 

	 * @param focusListener

	 *            a {@link org.eclipse.swt.events.FocusListener} object.

	 */

	protected void setFocusListener(FocusListener focusListener) {

		this.focusListener = focusListener;

	}

	private FocusListener getFocusListener() {

		return focusListener;

	}

	/**

	 * <p>

	 * setDirty

	 * </p>

	 * 

	 * @param isDirty

	 *            a boolean.

	 */

	public void setDirty(boolean isDirty) {

		if (isDirty) {

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

		}

		this.isDirty = isDirty;

	}

	/**

	 * <p>

	 * isDirty

	 * </p>

	 * 

	 * @return a boolean.

	 */

	public boolean isDirty() {

		return isDirty;

	}

	/**

	 * <p>

	 * setMenu

	 * </p>

	 * 

	 * @param menu

	 *            a {@link org.eclipse.swt.widgets.Menu} object.

	 */

	public void setMenu(Menu menu) {

		control.setMenu(menu);

		getNameViewer().setMenu(menu);

	}

	private Control[] draggableControls;

	/**

	 * <p>

	 * setDraggableControl

	 * </p>

	 * 

	 * @param controls

	 *            an array of {@link org.eclipse.swt.widgets.Control} objects.

	 */

	protected void setDraggableControl(Control[] controls) {

		draggableControls = controls;

	}

	/**

	 * <p>

	 * setIsDraggable

	 * </p>

	 * 

	 * @param draggable

	 *            a boolean.

	 */

	public void setIsDraggable(boolean draggable) {

		if (draggable) {

			if (draggableControls == null) {

				throw new NullPointerException(

						"Draggable controls must be set to add draggability");

			}

			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 NameEditorDragListener(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) {