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

import java.util.Set;

import javax.naming.OperationNotSupportedException;

import org.apache.log4j.Logger;

import org.eclipse.core.runtime.Assert;

import org.eclipse.jface.dialogs.Dialog;

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

import eu.etaxonomy.taxeditor.singlesource.editor.name.container.EditorAnnotationFacade;

import eu.etaxonomy.taxeditor.singlesource.editor.name.container.EditorAnnotationFacade.EditorAnnotationType;

import eu.etaxonomy.taxeditor.singlesource.editor.name.container.INameViewer;

import eu.etaxonomy.taxeditor.singlesource.editor.name.container.LineBreakListenerFacade;

import eu.etaxonomy.taxeditor.singlesource.editor.name.container.LineWrapSupportFacade;

import eu.etaxonomy.taxeditor.singlesource.editor.name.container.NameViewerFacade;

import eu.etaxonomy.taxeditor.singlesource.org.eclipse.jface.text.IPosition;

import eu.etaxonomy.taxeditor.singlesource.org.eclipse.jface.text.PositionFacade;

import eu.etaxonomy.taxeditor.singlesource.org.eclipse.jface.window.IToolTip;

import eu.etaxonomy.taxeditor.singlesource.org.eclipse.jface.window.ToolTipFacade;

import eu.etaxonomy.taxeditor.singlesource.org.eclipse.swt.widgets.DisplayProxy;

/**

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

	private static final Logger logger = Logger.getLogger(AbstractGroupedContainer.class);

	protected ParseHandler parseHandler;

	private FocusListener nameCompositeFocusListener;

	private ModifyListener nameCompositeModifyListener;

	protected NameViewerFacade nameViewer;

	private AbstractGroup group;

	private Label nonEditableInfoLabel;

	private IToolTip nonEditableInfoHover;

	private static AbstractGroupedContainer selection;

	private FocusListener focusListener;

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

		try {

			createTextViewer();

			createLineWrapSupport();

			createLineBreakListener();

		} catch (OperationNotSupportedException e) {

			logger.warn("AbstractGroupedContainer.createContent(): Operation not supported:" +  e.getMessage());

		}

		setMenu(getEditor().getMenu());

		setDraggableControl(new Control[]{getControl(), getNameViewer().getDraggableControl()});

		createEmptyViewerPrompt(EMPTY_NAME_PROMPT);

		initializeComposite();

		createListener();

		try {

			isFreeTextEnabled();

		} catch (OperationNotSupportedException e) {

			logger.warn("AbstractGroupedContainer.initTextViewer(): EditorAnnotations not supported :" + e.getMessage());

		}

	}

	/**

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

				NonViralName name = parseHandler.parse(text);

				getTaxonBase().setName(name);

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

				// show errors resulting from parsing

				try {

					calculateAnnotations();

				} catch (OperationNotSupportedException e1) {

					logger.warn("AbstractGroupedContainer.createListener(): EditorAnnotations not supported :" + e1.getMessage() );

				}

				// 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().addModifyListener(nameCompositeModifyListener);

		getNameViewer().addFocusListener(nameCompositeFocusListener);

	}

	private void removeListener(){

		getNameViewer().removeModifyListener(nameCompositeModifyListener);

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

		}

		try {

			calculateAnnotations();

		} catch (OperationNotSupportedException e) {

			logger.warn("AbstractGroupedContainer.initTextViewer(): EditorAnnotations not supported :" + e.getMessage() );

		}

	}

	/**

	 * <p>calculateErrors</p>

	 * @throws OperationNotSupportedException 

	 */

	synchronized protected void calculateAnnotations() throws OperationNotSupportedException {

		getNameViewer().clearAnnotations();

		showAnnotations();

	}

	/**

	 * 

	 */

	public void showAnnotations() throws OperationNotSupportedException {

		if(getName().hasProblem()){

			showParsingProblems();

		}

		if(!isNameParsable()){

			getNameViewer().addAnnotation(

					new EditorAnnotationFacade(EditorAnnotationType.WARNING, 0, "This name may only be edited in the details view."));

		}

		if(isNameUsedMultipleTimes()){

			getNameViewer().addAnnotation(new EditorAnnotationFacade(EditorAnnotationType.WARNING, 0, "This taxons name is used multiple times."));

		}

	}

	/**

	 * @throws OperationNotSupportedException 

	 * 

	 */

	private void showParsingProblems() throws OperationNotSupportedException {

		String text = getNameViewer().getText();

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

		for (ParserProblem problem : parsingProblems) {

			getNameViewer().addAnnotation(new EditorAnnotationFacade(problem), getParsingProblemPosition());

		}	

	}

	private IPosition getParsingProblemPosition() throws OperationNotSupportedException{

		String text = getNameViewer().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;

			}

			return new PositionFacade(start, length);

		}

		return null;

	}

	/**

	 * <p>handleSplitText</p>

	 *

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

	 */

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

/* RAP SS-Exclude, obviously not needed		

//		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().getText().equals(text)) {

			removeListener();

			getNameViewer().setText(text);

			addListener();

		}

		updateNonEditableInfo();

		updateIcon();

//		placeCursor();

		updateIndent();

		try {

			isFreeTextEnabled();

		} catch (OperationNotSupportedException e) {

			logger.warn("AbstractGroupedContainer.initTextViewer(): EditorAnnotations not supported :" + e.getMessage() );

		}

	}

	/**

	 * 

	 */

	protected abstract void updateIcon();

	protected abstract void updateIndent();

	/**

	 * <p>updateNonEditableInfo</p>

	 */

	protected abstract void updateNonEditableInfo();

	/**

	 * @throws OperationNotSupportedException 

	 * 

	 */

	private void isFreeTextEnabled() throws OperationNotSupportedException {

		// Decide whether editing of freetext is allowed or not.

		if (freetextEditingAllowed()) {

			// set editable

			getNameViewer().setEditable(true);

			// restore foreground font color again

			getNameViewer().setForeground(control.getForeground());

		} else {

			// set non-editable

			getNameViewer().setEditable(false);

			// grey out text as a non-editable indicator

			getNameViewer().setForeground(EditorUtil.getColor(Resources.COLOR_DISABLED_EDITOR));

		}

	}

	/**

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

	 * @return

	 */

	private boolean freetextEditingAllowed() {

		NonViralName name = (NonViralName) HibernateProxyHelper.deproxy(getName());

		boolean enableFreetext = true;

		enableFreetext |= isNameUsedMultipleTimes();

		enableFreetext &= isNameParsable();

		return enableFreetext;

	}

	private boolean isNameUsedMultipleTimes(){

		if(getName().getTaxonBases().size() > 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

	 * @throws OperationNotSupportedException 

	 */

	public void parseAndCalculateAnnotations() throws OperationNotSupportedException{

		removeListener();

		String unparsedNameString = getNameViewer().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()){

			try {

				getNameViewer().setEnabled(false);

			} catch (OperationNotSupportedException e) {

				logger.warn("AbstractGroupedContainer.persistName(): " + e.getMessage() );

			}

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

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

//

//				@Override

//				protected IStatus run(IProgressMonitor monitor) {

//					

					final NonViralName name = parseHandler.parseAndResolveDuplicates(unparsedNameString);

//					

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

//						public void run() {

							getTaxonBase().setName(name);

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

							setDirty(false);

							try {

								getNameViewer().setEnabled(true);

							} catch (OperationNotSupportedException e) {

								logger.warn("AbstractGroupedContainer.persistName(): " + e.getMessage() );

							}							

//						};

//					});

//					

//					

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

	 * @throws OperationNotSupportedException 

	 */

	protected void createLineWrapSupport() throws OperationNotSupportedException {

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

	}

	/**

	 * <p>createTextViewer</p>

	 * @throws OperationNotSupportedException 

	 */

	protected void createTextViewer() throws OperationNotSupportedException {

		nameViewer = new NameViewerFacade(control);

		focusListener = new FocusAdapter() {

			@Override

			public void focusGained(FocusEvent e) {

				for(AbstractGroupedContainer container : getEditor().getGroupedContainers()){

					container.colorSelected(NOT_SELECTED);

				}

				getEditor().getManagedForm().setInput(AbstractGroupedContainer.this);

				placeCursor();

				colorSelected(SELECTED_FOCUS);

			}

		};

		nameViewer.addFocusListener(focusListener);

//		

		MouseAdapter mouseListener = new MouseAdapter() {

			@Override

			public void mouseDown(MouseEvent e) {

				storeCursor();

			}

		};

		control.addMouseListener(mouseListener);

		nameViewer.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().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 = DisplayProxy.getDefault();

		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().setFont(font);

	}

	/**

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

	 *

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

	 */

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

		setFocusListener(new FocusListener() {

			public void focusGained(FocusEvent e) {

				try {

					if (getNameViewer().getDocumentAsString().equals(prompt)) {

						getNameViewer().setFont(getViewerFont());

						getNameViewer().setDocumentAsString("");

					}

				} catch (OperationNotSupportedException e1) {

				}

			}

			public void focusLost(FocusEvent e) {

				try {

					if (getNameViewer().getDocumentLength() == 0) {

						initEmptyText();

					}

				} catch (OperationNotSupportedException e1) {

				}

			}

		});

		getNameViewer().addFocusListener(getFocusListener());

		try {

			if (getNameViewer().getDocumentLength() == 0) {

				getNameViewer().setFont(EditorUtil.getFont(Resources.FONT_DEFAULT_PROMPT));

				getNameViewer().setDocumentAsString(prompt);

			}

		} catch (OperationNotSupportedException e1) {

		}

	}

	/**

	 * <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().setFont(defaultFont);

		getNameViewer().setDocumentAsString(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) {

				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

	 * @throws OperationNotSupportedException 

	 */

	public void setNonEditableInfo(String info, boolean append) throws OperationNotSupportedException {

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

		info = info.toUpperCase();

		if(append){

			nonEditableText += ", " + info;

			nonEditableHoverText += "\n" + info;

		}else{

			nonEditableText = info;

			nonEditableHoverText = info;

		}

		if (nonEditableInfoLabel == null) {

			nonEditableInfoLabel = getEditor().getToolkit().createLabel(control, "");

			TableWrapData layoutData = new TableWrapData(TableWrapData.FILL_GRAB, TableWrapData.TOP);

			// Set indent to viewer ruler's width 

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

				// TODO right justify

				layoutData.indent = INameViewer.RULER_WIDTH;

			}

			nonEditableInfoLabel.setLayoutData(layoutData);