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;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.util.Set;

import org.apache.log4j.Logger;

import org.eclipse.core.commands.operations.IUndoableOperation;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.DropTarget;

import org.eclipse.swt.dnd.DropTargetAdapter;

import org.eclipse.swt.dnd.DropTargetEvent;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.PartInitException;

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.AbstractTaxonEditor;

import eu.etaxonomy.taxeditor.editor.EditorUtil;

import eu.etaxonomy.taxeditor.editor.FreeTextElementFactory;

import eu.etaxonomy.taxeditor.editor.GroupedComposite;

import eu.etaxonomy.taxeditor.editor.MultiPageTaxonEditor;

import eu.etaxonomy.taxeditor.editor.WidgetTransfer;

import eu.etaxonomy.taxeditor.store.model.Resources;

import eu.etaxonomy.taxeditor.store.operations.ChangeConceptToSynonymOperation;

import eu.etaxonomy.taxeditor.store.operations.ChangeHomotypicGroupOperation;

/**

 * @author p.ciardelli

 * @created 15.05.2008

 * @version 1.0

 */

public class TaxonNameEditor extends AbstractTaxonEditor 

		implements INameEditorCompositeRepository {

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

	private static final String ID = "eu.etaxonomy.taxeditor.taxonNameEditor";

	public TaxonNameEditor(MultiPageTaxonEditor editor){

		super(editor);

	}

	/**

	 * Shared listener that sets dirty state to true 

	 *  when any registered property changes 

	 */

	private PropertyChangeListener taxonChangeListener = new PropertyChangeListener() {

		public void propertyChange(PropertyChangeEvent event) {

			if (event.getPropertyName().equals(Resources.PROPERTY_SHEET_CHANGE)) {

				firePropertyChange(PROP_DIRTY);

			}

		}

	};

	@Override

	public void doSave(IProgressMonitor monitor) {}

	@Override

	public void doSaveAs() {}

	@Override

	public void init(IEditorSite site, IEditorInput input)

			throws PartInitException {

		super.init(site, input);

		// Register listeners for any change in accepted name or set of relations

		taxon.getName().addPropertyChangeListener(taxonChangeListener);

		taxon.addPropertyChangeListener(taxonChangeListener);

	}

	@Override

	public boolean isDirty() {

		return false;

	}

	@Override

	public boolean isSaveAsAllowed() {

		return false;

	}

	@Override

	protected void createManagedForm(Composite composite) {

		super.createManagedForm(composite);

		Taxon taxon = getTaxon();

		firstGroupedComposite = (NameComposite) FreeTextElementFactory.getDefault().

				createAcceptedTaxon(this);

		// Draw synonym and misapplied name elements

		for (TaxonBase<?> taxonBase : new IterableSynonymyList(taxon)) {

			if (taxonBase instanceof Synonym) {

				FreeTextElementFactory.getDefault().createSynonym(this, (Synonym) taxonBase);				

			} else {

				FreeTextElementFactory.getDefault().createMisappliedName(this, (Taxon) taxonBase);

			}

		}

		// Draw concept relation elements

		Set<TaxonRelationship> taxonRelations = taxon.getTaxonRelations();

		for (TaxonRelationship relationship : taxonRelations) {

			if (relationship.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR()) ||

					relationship.getType().equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN())) {

				continue;

			}

			FreeTextElementFactory.getDefault().createConcept(this, relationship);

		}		

		// Listen for names being dragged outside of existing homotypic groups -

		//  user wants to create a new group

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

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

		DropTarget target = new DropTarget(parent, operations);

		target.setTransfer(types);

		target.addDropListener(new DropTargetAdapter() {

			public void drop(DropTargetEvent event) {

				if (event.data instanceof GroupedComposite) {

					final GroupedComposite composite = (GroupedComposite) event.data;

					if (composite.getDragSource() != null) {

							// Execute operations at end of drag event

							composite.getDragSource().addListener(DND.DragEnd, new Listener() {

								public void handleEvent(Event event) {

									IUndoableOperation operation = null;

									// Synonym being dropped

									if(composite instanceof SynonymComposite){

										Synonym synonym = ((SynonymComposite)composite).getSynonym();

										operation = new ChangeHomotypicGroupOperation

												("change type", getUndoContext(), 

														getTaxon(), synonym, HomotypicalGroup.NewInstance(), TaxonNameEditor.this);

									}

									// Misapplied name being dropped

									if(composite instanceof MisappliedNameComposite){

											Taxon misapplication = ((MisappliedNameComposite)composite).getMisappliedName();

											operation = new ChangeConceptToSynonymOperation

													("change misapplied name to synonym", getUndoContext(), 

															getTaxon(), misapplication, HomotypicalGroup.NewInstance(), TaxonNameEditor.this);					

									}

									// Execute operation if it's been init'ed

									if (operation == null) {

										logger.warn("User unsuccessfully tried to drop " + composite.getClass());

									} else {

										EditorUtil.executeOperation(operation);

									}

								}

							});							

					}

				}

			}		

		});				

		setFocus();

		// Redraw composite

		composite.layout();

	}

	public Composite getAcceptedName() {

		for(Composite c : getAllComposites()){

			if(c instanceof AcceptedNameComposite){

				return c;

			}

		}

		return null;

	}

	public Composite getHomotypicGroup(HomotypicalGroup group) {

		for(Composite c : getAllComposites()){

			if(c instanceof HomotypicalGroupComposite){

				if (group.equals(

						((HomotypicalGroupComposite) c).getGroup())) {

					return c;

				}

			}

		}

		return null;

	}

	public Composite getMisappliedGroup() {

		for(Composite c : getAllComposites()){

			if(c instanceof MisappliedGroupComposite){

				return c;

			}

		}

		return null;

	}

	public Composite getMisappliedName(Taxon misappliedName) {

		for(Composite c : getAllComposites()){

			if(c instanceof MisappliedNameComposite){

				if (misappliedName.equals(

						((MisappliedNameComposite) c).getMisappliedName())) {

					return c;

				}

			}

		}

		return null;

	}

	public Composite getSynonym(Synonym synonym) {

		for(Composite c : getAllComposites()){

			if(c instanceof SynonymComposite){

				if (synonym.equals 

						(((SynonymComposite) c).getSynonym())) {

					return c;

				}

			}

		}

		return null;

	}

	public Composite getConceptGroup() {

		for(Composite c : getAllComposites()){

			if(c instanceof ConceptGroupComposite){

				return c;

			}

		}

		return null;

	}

	public Composite getConcept(Taxon relatedConcept) {

		for(Composite c : getAllComposites()){

			if(c instanceof ConceptComposite){

				if (relatedConcept.equals 

						(((ConceptComposite) c).getRelatedTaxon())) {

					return c;

				}

			}

		}

		return null;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.taxeditor.editor.AbstractTaxonEditor#getID()

	 */

	@Override

	public String getID() {

		return TaxonNameEditor.ID;

	}

}