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;

import org.apache.log4j.Logger;

import org.eclipse.core.runtime.Assert;

import org.eclipse.jface.dialogs.Dialog;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.TextViewer;

import org.eclipse.jface.window.DefaultToolTip;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.StyledText;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.DragSource;

import org.eclipse.swt.dnd.DragSourceAdapter;

import org.eclipse.swt.dnd.DragSourceEvent;

import org.eclipse.swt.dnd.DragSourceListener;

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

import org.eclipse.swt.events.MouseEvent;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Font;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.ui.forms.IManagedForm;

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

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

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

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

import eu.etaxonomy.taxeditor.store.model.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

 * @created 02.06.2008

 * @version 1.0

 */

abstract public class GroupedComposite extends Composite implements IHasPropertySource {	

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

	protected AbstractTaxonEditor editor;

	protected NameViewer textViewer;

	protected IManagedForm managedForm;

	private Label nonEditableInfoLabel;

	private DefaultToolTip nonEditableInfoHover;

	private Color defaultGroupBackgroundColor = Resources.getColor(Resources.COLOR_COMPOSITE_BACKGROUND);

	protected Taxon taxon;

	private CompositeBorderDecorator borderDecorator;	

	private FocusListener focusListener;

	private LineBreakListener lineBreakListener;

	private ParseListener parseListener;

	private String emptyViewerPrompt;

	public GroupedComposite(AbstractTaxonEditor editor, Composite parent){

		super(parent, SWT.NONE);

		this.editor = editor;

		this.managedForm = editor.getManagedForm();

		Object formData = managedForm.getForm().getBody().getData();

		Assert.isTrue(formData instanceof Taxon, 

				"Managed form must have a Taxon in its data field.");

		taxon = (Taxon) formData;

		createControl();

	}

	protected void createControl() {

		setLayoutData(new TableWrapData(TableWrapData.FILL_GRAB));

		TableWrapLayout layout = new TableWrapLayout();

		layout.leftMargin = 0;

		layout.topMargin = 0;

		layout.bottomMargin = 0;

		layout.verticalSpacing = 0;

		setLayout(layout);

		setBackground(defaultGroupBackgroundColor);

	}

	protected void createLineWrapSupport() {

		if (textViewer instanceof NameViewer) {

			new LineWrapSupport(textViewer, managedForm);

		} else {

			logger.warn("Can't create line wrap support because textViewer has not been initialized.");

		}

	}

	public Taxon getTaxon() {

		return taxon;

	}

	protected void createTextViewer() {

		textViewer = new NameViewer(this);

		focusListener = new FocusAdapter() {

			public void focusGained(FocusEvent e) {

				setFocus();

			}

		};

		textViewer.getTextWidget().addFocusListener(focusListener);

		MouseAdapter mouseListener = new MouseAdapter() {

			public void mouseDown(MouseEvent e) {

				setFocus();				

			}

		};

		this.addMouseListener(mouseListener);

		textViewer.getRulerControl().addMouseListener(mouseListener);

	}

	/**

	 * @param icon

	 */

	public void setIcon(Image icon) {

		if (textViewer instanceof NameViewer) {

			textViewer.setIcon(icon);

		} else {

			logger.warn("Can't set icon because textViewer has not been initialized.");

		}

	}

	/**

	 * @param indent

	 */

	public void setIndent(int indent) {

		if (getLayout() instanceof TableWrapLayout) {

			TableWrapLayout layout = ((TableWrapLayout) getLayout());

			layout.leftMargin = indent;

			this.setLayout(layout);

		} else {

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

		}

	}	

	/* (non-Javadoc)

	 * @see org.eclipse.swt.widgets.Composite#setFocus()

	 */

	public boolean setFocus() {

		setSelection();

		return true;

	}

	/**

	 * Set background on selection and the cursor to EOL

	 * I wanted to move this to setFocus() but that leads to an infinite loop

	 */

	public void setSelected(){

		setBackground(Resources.getColor(Resources.COLOR_COMPOSITE_SELECTED));

		if(textViewer != null){

			textViewer.setCursorToEOL();

		}

	}

	/**

	 * 

	 */

	protected void setSelection() {

		managedForm.setInput(this);

	}

	/**

	 * 

	 */

	@Override

	public void setBackground(Color color) {

		super.setBackground(color);

		if(textViewer != null){

			textViewer.setBackground(color);

		}

	}

	/* (non-Javadoc)

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

	 */

	public void setFont(Font font) {

		if (textViewer != null) {

			textViewer.getTextWidget().setFont(font);

		} else {

			logger.warn("Can't set font because textViewer has not been initalized.");

		}

	}

	public TextViewer getTextViewer() {

		return textViewer;

	}

	/**

	 * 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

	 */

	public void createEmptyViewerPrompt(final String prompt) {

		emptyViewerPrompt = prompt;

		Assert.isNotNull(textViewer);

//		new EmptyTextViewerPrompt(getTextViewer(), prompt);

		final StyledText textControl = textViewer.getTextWidget();

		final IDocument document = textViewer.getDocument();

		final Font promptFont = Resources

				.getFont(Resources.FONT_DEFAULT_PROMPT);

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

			document.set(prompt);

		}

	}

	abstract protected Font getViewerFont();

	protected void initEmptyText() {

		textViewer.getTextWidget().setFont(

				Resources

					.getFont(Resources.FONT_DEFAULT_PROMPT));

		textViewer.getDocument().set(getEmptyTextPrompt());

		textViewer.setCursorToEOL();

	}

	protected String getEmptyTextPrompt() {

		if (emptyViewerPrompt == null) {

			emptyViewerPrompt = "Click to edit";

		}

		return emptyViewerPrompt;

	}

	private void setFocusListener(FocusListener focusListener) {

		this.focusListener = focusListener;

	}

	private FocusListener getFocusListener() {

		return focusListener;

	}

	/**

	 * 

	 */

	public void createBorderSupport() {

		if (textViewer == null) {

			logger.warn("Could not create border support - getTextViewer() returned null.");

		} else {

			borderDecorator = new CompositeBorderDecorator(

					textViewer.getTextWidget(), managedForm);		

			borderDecorator.setLoseFocus(false);

			textViewer.getTextWidget().addFocusListener(borderDecorator);

		}

	}

	protected void setBorderDecorator(CompositeBorderDecorator borderDecorator) {

		this.borderDecorator = borderDecorator;

	}

	protected CompositeBorderDecorator getBorderDecorator() {

		return borderDecorator;

	}

	public void drawBorder() {

		if (borderDecorator != null) {

			borderDecorator.paintBorder();

		}

	}

	/**

	 * @param isDirty

	 */

	protected void setDirty(boolean isDirty) {

		managedForm.dirtyStateChanged();

	}

	protected ContextMenu createContextMenu() {

		if (textViewer != null) {

			ContextMenu contextMenu = new ContextMenu(textViewer.getRulerControl());

			textViewer.getTextWidget().setMenu(contextMenu.getMenu());

			return contextMenu;

		} else {

			logger.warn("Can't create menu because textViewer has not been initalized.");

			return null;

		}

	}

	public void setMenu (Menu menu) {

		super.setMenu(menu);

		if (textViewer != null) {

			textViewer.getRulerControl().setMenu(menu);

			textViewer.getTextWidget().setMenu(menu);

		}

	}

	public void unpaintBorder() {

		if (borderDecorator != null) {

			borderDecorator.unpaintBorder();

		}

	}

	private Control draggableControl;

	private DragSource dragSource;

	protected void setDraggableControl(Control control) {

		draggableControl = control;

	}

	public DragSource getDragSource() {

		return dragSource;

	}

	public void setIsDraggable(boolean draggable) {

		if (draggable) {

			if (dragSource != null) {

				// Already initialized

				return;

			}

			if (draggableControl == null) {

				throw new NullPointerException(

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

			}

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

			int operations = DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK;

			dragSource = new DragSource(draggableControl, operations);

			dragSource.setTransfer(types);

			dragSource.addDragListener(dragSourceListener);

		} else {

			dragSource = null;

		}

	}

	/**

	 * Drag listener which passes the Composite as the data in a drag event.

	 */

	DragSourceListener dragSourceListener = new DragSourceAdapter() {

		public void dragStart(DragSourceEvent event) {

			if (textViewer != null) {

				textViewer.getTextWidget().setFocus();

			}

			event.doit = true;

		}

		public void dragSetData(DragSourceEvent event) {

			WidgetTransfer.getInstance().setWidget(GroupedComposite.this);

		}

	};

	private String nonEditableText;

	ControlListener nonEditableResizeListener = new ControlAdapter() {

		int width = 0;

		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;

	/**

	 * 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

	 */

	public void setNonEditableInfo(String info) {

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

		info = info.toUpperCase();

		if (nonEditableInfoLabel == null) {

			nonEditableText = info;

			nonEditableHoverText = info;

			nonEditableInfoLabel = new Label(this, SWT.NONE);

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

			// Set indent to viewer ruler's width 

			if (textViewer != null && textViewer.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);

		} else {

			nonEditableText += ", " + info;

			nonEditableHoverText += "\n" + info;

		}

		nonEditableInfoHover.setText(nonEditableHoverText);

	}

	/**

	 * If the user entering text requires parsing, call this method and override

	 * the method parse().

	 */

	protected void createParser() {

		if (textViewer != null) {

			parseListener = new ParseListener() {

				@Override

				public void parse(String text) {

					GroupedComposite.this.parse(text);

				}

			};

			textViewer.getTextWidget().addModifyListener(parseListener);

		} else {

			logger.warn("Can't create parser because textViewer has not been initalized.");

		}

	}

	/**

	 * Supposed to be overridden in implementing classes

	 * 

	 * @param text

	 */

	protected void parse(String text) {

		logger.warn("No parse method defined for this composite.");

	}

	/**

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

		if (textViewer != null) {

			lineBreakListener = new LineBreakListener() {

				@Override

				public void handleSplitText(String text) {

					GroupedComposite.this.handleSplitText(text);	

				}

			};

			textViewer.getTextWidget().addVerifyListener(lineBreakListener);

			textViewer.getTextWidget().addKeyListener(lineBreakListener);

		} else {

			logger.warn("Can't create line break listener because textViewer has not been initalized.");

		}

	}

	/**

	 * Supposed to be overridden in implementing classes

	 * 

	 * @param text

	 */

	protected void handleSplitText(String text) {

		logger.warn("No handleSplitText method defined for this composite.");

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.taxeditor.editor.name.GroupedComposite#dispose()

	 */

	public void dispose () {

		if (dragSource != null) {

			dragSource.removeDragListener(dragSourceListener);

		}		

		if (textViewer != null) {

			StyledText textWidget = textViewer.getTextWidget();

			if (focusListener != null) {

				textWidget.removeFocusListener(focusListener);

			}

			if (parseListener != null) {

				textWidget.removeModifyListener(parseListener);

			}

			if (lineBreakListener != null) {

				textWidget.removeVerifyListener(lineBreakListener);

				textWidget.removeKeyListener(lineBreakListener);

			}

			if (borderDecorator != null) {

				textWidget.removeFocusListener(borderDecorator);

			}

		}

		if (nonEditableInfoLabel != null && nonEditableLabelEllipsisListener != null) {

			nonEditableInfoLabel.removeControlListener(nonEditableLabelEllipsisListener);

		}

		super.dispose();

	}

	public static final String ELLIPSIS = "...";

	/**

	 * @param textValue

	 * @param control

	 * @return

	 * @see org.eclipse.jface.dialogs.Dialog#shortenText(String, Control)

	 */

	public static String shortenText(String textValue, Control control) {

		if (textValue == null) {

			return null;

		}

		GC gc = new GC(control);

		int maxWidth = control.getBounds().width;

		int maxExtent = gc.textExtent(textValue).x;

		if (maxExtent < maxWidth) {

			gc.dispose();

			return textValue;

		}

		int length = textValue.length();

		int charsToClip = Math.round(0.95f*length * (1 - ((float)maxWidth/maxExtent)));

		int end = length - charsToClip;

		while (end > 0) {

			String s1 = textValue.substring(0, end);

			String s = s1 + ELLIPSIS;

			int l = gc.textExtent(s).x;

			if (l < maxWidth) {

				gc.dispose();

				return s;

			}

			end--;

		}

		gc.dispose();

		return textValue;

	}

	abstract class LabelEllipsisListener extends ControlAdapter {

		private Label label;

		int width = 0;

		LabelEllipsisListener(Label label) {

			this.label = label;

		}

		abstract public String getLabelText();

		public void controlResized(ControlEvent e) {

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

				return;

			}

			width = label.getBounds().width;

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

				label.setText(

//						Dialog.shortenText(getLabelText(), label));

						shortenText(getLabelText(), label));

			}

		}

	}

}