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

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.apache.log4j.Logger;

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

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.OperationCanceledException;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionProvider;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.DropTarget;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.ISelectionListener;

import org.eclipse.ui.ISelectionService;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.IWorkbenchPartReference;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.forms.ManagedForm;

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

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

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

import org.eclipse.ui.part.EditorPart;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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

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

import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;

import eu.etaxonomy.taxeditor.editor.CdmDataTransfer;

import eu.etaxonomy.taxeditor.editor.EditorUtil;

import eu.etaxonomy.taxeditor.editor.IDropTargetable;

import eu.etaxonomy.taxeditor.editor.IMultiPageTaxonEditorPage;

import eu.etaxonomy.taxeditor.editor.MultiPageTaxonEditor;

import eu.etaxonomy.taxeditor.editor.SimpleSelectionProvider;

import eu.etaxonomy.taxeditor.editor.TaxonEditorInput;

import eu.etaxonomy.taxeditor.model.IPartChangeListener;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.TaxeditorPartService;

import eu.etaxonomy.taxeditor.operations.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.preference.Resources;

/**

 * <p>TaxonNameEditor class.</p>

 *

 * @author p.ciardelli

 * @author n.hoffmann

 * @created 15.05.2008

 * @version 1.0

 */

public class TaxonNameEditor extends EditorPart implements IMultiPageTaxonEditorPage, IAdaptable, IConversationEnabled, IPostOperationEnabled, IPartContentHasDetails, IPartChangeListener

		, ISelectionListener, IDropTargetable {

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

	public class Tupel{

		public HomotypicalGroup homotypicalGroup;

		public HomotypicalSynonymGroup group;

		public Tupel(HomotypicalGroup homotypicalGroup, HomotypicalSynonymGroup group){

			this.homotypicalGroup = homotypicalGroup;

			this.group = group;

		}

	}

	/** Constant <code>ID="eu.etaxonomy.taxeditor.taxonNameEditor"</code> */

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

	private Taxon taxon;

	private ManagedForm managedForm;

	private ScrolledForm scrolledForm; 

	private Composite parent;

	private ISelectionProvider provider;

	private MultiPageTaxonEditor editor;

	private AbstractGroupedContainer selectedObject;

	private AcceptedNameContainer acceptedNameContainer;

	private ConversationHolder conversation;

	private MenuManager menuManager;

	private Menu menu;

	private List<Tupel> heterotypicSynonymGroupTupel = new ArrayList<Tupel>();

	private MisappliedGroup misappliedGroup;

	private ConceptGroup conceptGroup;

	private DropTarget target;

	private ISelectionService selectionService;

	private ContainerFactory containerFactory;

	private HomotypicalSynonymGroup homotypicalSynonymGroup;

	private AbstractGroupedContainer objectAffectedByLastOperation;

	/**

	 * <p>Constructor for TaxonNameEditor.</p>

	 *

	 * @param editor a {@link eu.etaxonomy.taxeditor.editor.MultiPageTaxonEditor} object.

	 */

	public TaxonNameEditor(MultiPageTaxonEditor editor){

		this.editor = editor;

		conversation = editor.getConversationHolder();

		containerFactory = ContainerFactory.getInstance();

	}

	/**

	 * <p>getUndoContext</p>

	 *

	 * @return a {@link org.eclipse.core.commands.operations.IUndoContext} object.

	 */

	public IUndoContext getUndoContext() {

		return editor.getUndoContext();

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite)

	 */

	/** {@inheritDoc} */

	public void createPartControl(Composite composite) {

		selectionService = getSite().getWorkbenchWindow().getSelectionService();

		selectionService.addSelectionListener(this);

		createManagedForm(composite);

		TaxeditorPartService.getInstance().addListener(TaxeditorPartService.PART_ACTIVATED, this);

	}

	/**

	 * <p>createManagedForm</p>

	 *

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

	 */

	protected void createManagedForm(Composite composite) {

		managedForm = new ManagedForm(composite) {

			public void dirtyStateChanged() {

				firePropertyChange(PROP_DIRTY);

			}

			public boolean setInput(Object input) {

				if (input instanceof AbstractGroupedContainer) {

					selectedObject = (AbstractGroupedContainer) input;

					provider.setSelection(new StructuredSelection(selectedObject.getData()));

				}

				return super.setInput(input); 

			}

		};

		scrolledForm = managedForm.getForm();

		parent = scrolledForm.getBody();

		// register the context menu

		menuManager = new MenuManager();

		ISelectionProvider selectionProvider = getSite().getSelectionProvider();

		getSite().registerContextMenu(TaxonNameEditor.ID, menuManager, selectionProvider);

		parent.setData(taxon);

		TableWrapLayout layout = new TableWrapLayout();

		layout.leftMargin = 0;

		layout.rightMargin = 0;

		layout.topMargin = 0;

		layout.bottomMargin = 0;

		layout.verticalSpacing = 0;

		layout.horizontalSpacing = 0;

		parent.setLayout(layout);	

		parent.setBackground(EditorUtil.getColor(Resources.COLOR_COMPOSITE_BACKGROUND));

		createNameComposites();

		createDragSupport();

		setFocus();

	}

	/**

	 * <p>createNameComposites</p>

	 */

	protected void createNameComposites(){

		containerFactory.createAcceptedTaxonsHomotypicGroup(this);

		containerFactory.createHeterotypicSynonymGroups(this);

		containerFactory.createMisapplicationGroup(this);

		containerFactory.createConceptGroup(this);

		for(AbstractGroupedContainer container : getGroupedContainers()){

			container.setMenu(getMenu());

		}

		// Redraw composite

		managedForm.reflow(true);

	}

	/**

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

	 *

	 * @return a {@link eu.etaxonomy.cdm.model.taxon.Taxon} object.

	 */

	public Taxon getTaxon() {

		return (Taxon) HibernateProxyHelper.deproxy(taxon);

	}

	/**

	 * <p>setDirty</p>

	 */

	public void setDirty() {

		managedForm.dirtyStateChanged();

	}

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.ui.part.WorkbenchPart#setFocus()

	 */

	/** {@inheritDoc} */

	@Override

	public void setFocus(){

		getSelectedObject().setSelected();

	}

	/** {@inheritDoc} */

	public void setInput(IEditorInput input){

		this.setInputWithNotify(input);		

	}

	/*

	 * (non-Javadoc)

	 * @see eu.etaxonomy.cdm.api.conversation.IConversationEnabled#getConversationHolder()

	 */

	/**

	 * <p>getConversationHolder</p>

	 *

	 * @return a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder} object.

	 */

	public ConversationHolder getConversationHolder(){

		return conversation;

	}

	/*

	 * (non-Javadoc)

	 * @see eu.etaxonomy.cdm.persistence.hibernate.ICdmPostCrudObserver#update(eu.etaxonomy.cdm.persistence.hibernate.CdmCrudEvent)

	 */

	/** {@inheritDoc} */

	public void update(CdmDataChangeMap events) {

		//redraw();

	}

	/**

	 * Redraws this editor

	 * return true on success

	 *

	 * @return a boolean.

	 */

	public boolean redraw(){

		return redraw(true);

	}

	/**

	 * {@inheritDoc}

	 *

	 * Redraws the editor controls

	 */

	public boolean redraw(boolean focus) {

		createNameComposites();

		if(focus){

			setFocus();

		}

		return true;		

	}

	private AbstractGroupedContainer getContainerForData(CdmBase data) {

		if(data == null && (selectedObject != null && ! selectedObject.getControl().isDisposed())){

			return selectedObject;

		}

		List<AbstractGroupedContainer> groupedContainers = getGroupedContainers();

		for(AbstractGroupedContainer container : groupedContainers){

			if(container.getData().equals(data)){

				return container;

			}

		}

		return acceptedNameContainer;

	}

	/**

	 * <p>getMultiPageTaxonEditor</p>

	 *

	 * @return a {@link eu.etaxonomy.taxeditor.editor.MultiPageTaxonEditor} object.

	 */

	public MultiPageTaxonEditor getMultiPageTaxonEditor() {

		return editor;

	}

	/*

	 * (non-Javadoc)

	 * @see eu.etaxonomy.taxeditor.store.operations.IPostOperationEnabled#postOperation()

	 */

	/** {@inheritDoc} */

	public boolean postOperation(CdmBase objectAffectedByOperation) {

		editor.changed(objectAffectedByOperation);

		redraw(false);

		objectAffectedByLastOperation = getContainerForData(objectAffectedByOperation);

		return true;

	}

	private CdmBase getSelectedData() {

		if(selectedObject != null){

			return selectedObject.getData();

		}

		return null;

	}

	/**

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

	 *

	 * @return the managedForm

	 */

	public ManagedForm getManagedForm() {

		return managedForm;

	}

	/**

	 * <p>getControl</p>

	 *

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

	 */

	public Composite getControl() {

		return this.getManagedForm().getForm().getBody();

	}

	/**

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

	 *

	 * @return the menu

	 */

	public Menu getMenu() {

		if(menu == null || menu.isDisposed()){

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

				logger.error("Creating new Menu because it was disposed. This should not have happened");

			}

			menu = menuManager.createContextMenu(parent);

		}

		return menu;

	}

	/**

	 * <p>checkForEmptyNames</p>

	 *

	 * @return true if there are empty names

	 */

	public boolean checkForEmptyNames() {

		for(AbstractGroupedContainer container : getGroupedContainers()){

			if(container.getName() == null || container.getName().getTitleCache().equals("")){

				MessageDialog.openWarning(EditorUtil.getShell(), "No Name Specified", "An attempt was made to save a taxon or synonym with " +

				"an empty name. Operation was cancelled.");

				return true;

			}

		}

		return false;

	}

	/** {@inheritDoc} */

	@Override

	public void doSave(IProgressMonitor monitor) {

		monitor.beginTask("Saving names", getGroupedContainers().size());

        try {

			// check for empty names

			for(AbstractGroupedContainer container : getGroupedContainers()){

				monitor.subTask("Saving composite: " + container.getTaxonBase().getTitleCache());

				container.persistName();

				// In case the progress monitor was canceled throw an exception.

				if (monitor.isCanceled()) {

	            	throw new OperationCanceledException();

	            }

				// Otherwise declare this step as done.

				monitor.worked(1);

			}

        }

        finally {

        	// Stop the progress monitor.

        	monitor.done();

        }

	}

	/** {@inheritDoc} */

	@Override

	public void doSaveAs() {}

	/** {@inheritDoc} */

	@Override

	public void init(IEditorSite site, IEditorInput input)

			throws PartInitException {

		if (!(input instanceof IEditorInput))

			throw new PartInitException(

				"Invalid Input: Must be IEditorInput");

		if (input.getAdapter(Taxon.class) != null) {

			taxon = (Taxon) input.getAdapter(Taxon.class);

		} else {

			throw new PartInitException(

				"Invalid Input: Taxon cannot be null");

		}

		setSite(site);

		setInput(input);

		provider = new SimpleSelectionProvider();

		getSite().setSelectionProvider(provider);

		logger.trace("New Editor instance created.");

	}

	/**

	 * 

	 */

	private void createDragSupport() {

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

		//  user wants to create a new group

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

		int operations = DND.DROP_MOVE;

		if(target == null){

			target = new DropTarget(parent, operations);

			target.setTransfer(types);

			target.addDropListener(new NameEditorDropTargetListener(this));

		}		

	}

	/**

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

	 *

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

	 */

	public AcceptedNameContainer getAcceptedNameContainer() {

		return acceptedNameContainer;

	}

	/**

	 * <p>getSynonymGroup</p>

	 *

	 * @param homotypicalGroup a {@link eu.etaxonomy.cdm.model.name.HomotypicalGroup} object.

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

	 */

	public HomotypicalSynonymGroup getSynonymGroup(HomotypicalGroup homotypicalGroup) {

		if(getHomotypicSynonymGroup() != null && getHomotypicSynonymGroup().getGroup().equals(homotypicalGroup)){

			return getHomotypicSynonymGroup();

		}

		for(Tupel tupel : heterotypicSynonymGroupTupel){

			if(tupel.homotypicalGroup.equals(homotypicalGroup)){

				return tupel.group;

			}

		}

		return null;

	}

	/**

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

	 *

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

	 */

	public ConceptGroup getConceptGroup() {

		return conceptGroup;

	}

	/**

	 * <p>getDirtyNames</p>

	 *

	 * @return a Set containing all composites that have been edited

	 */

	public Set<AbstractGroupedContainer> getDirtyNames(){

		Set<AbstractGroupedContainer> dirtyNames = new HashSet<AbstractGroupedContainer>();

		for(AbstractGroupedContainer composite : getGroupedContainers()){

			if(composite.isDirty()){

				dirtyNames.add(composite);

			}

		}

		return dirtyNames;

	}

	/**

	 * <p>getGroupedContainers</p>

	 *

	 * @return a {@link java.util.List} object.

	 */

	public List<AbstractGroupedContainer> getGroupedContainers(){

		List<AbstractGroupedContainer> groupedComposites = new ArrayList<AbstractGroupedContainer>();

		for(AbstractGroup group : getAllGroups()){

			groupedComposites.addAll(group.getGroupedContainers());

		}

		return groupedComposites;

	}

	/**

	 * <p>getAllGroups</p>

	 *

	 * @return a {@link java.util.List} object.

	 */

	public List<AbstractGroup> getAllGroups(){

		List<AbstractGroup> allGroups = new ArrayList<AbstractGroup>();

		allGroups.add(getHomotypicSynonymGroup());

		allGroups.addAll(getHeterotypicSynonymGroups());

		if(misappliedGroup != null){

			allGroups.add(misappliedGroup);

		}

		if(conceptGroup != null){

			allGroups.add(conceptGroup);

		}

		return allGroups;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.part.EditorPart#isDirty()

	 */

	/** {@inheritDoc} */

	@Override

	public boolean isDirty() {

		return editor.isDirty();

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.part.WorkbenchPart#dispose()

	 */

	/** {@inheritDoc} */

	@Override

	public void dispose() {

		super.dispose();

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.part.EditorPart#isSaveAsAllowed()

	 */

	/** {@inheritDoc} */

	@Override

	public boolean isSaveAsAllowed() {

		return false;

	}

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.ui.ISelectionListener#selectionChanged(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.ISelection)

	 */

	/** {@inheritDoc} */

	public void selectionChanged(IWorkbenchPart part, ISelection selection) {

	}

	/**

	 * <p>removeContainer</p>

	 *

	 * @param container a {@link eu.etaxonomy.taxeditor.editor.name.AbstractGroupedContainer} object.

	 */

	public void removeContainer(AbstractGroupedContainer container) {

		container.remove();

	}

	/**

	 * <p>addCompositeForTaxonBase</p>

	 *

	 * @param taxonBase a {@link eu.etaxonomy.cdm.model.taxon.TaxonBase} object.

	 * @param target a {@link eu.etaxonomy.taxeditor.editor.IDropTargetable} object.

	 */

	public void addCompositeForTaxonBase(TaxonBase taxonBase, IDropTargetable target) {

//		if(target instanceof AbstractGroup){

//			((AbstractGroup) target).redraw();

//		}else if(target instanceof TaxonNameEditor){

//			if(taxonBase instanceof Synonym){

//				Synonym synonym = (Synonym) taxonBase;

//				HomotypicalSynonymGroup group = new HomotypicalSynonymGroup(this, synonym.getHomotypicGroup());

//				ContainerFactory.getInstance().createHeterotypicSynonymGroup(this, group);

//			}

//		}

//		if(taxonBase instanceof Synonym && target instanceof HomotypicalSynonymGroup){

//			new SynonymContainer(this, (HomotypicalSynonymGroup) target, (Synonym) taxonBase);

//		}else if(taxonBase instanceof Synonym && target instanceof TaxonNameEditor){

//			Synonym synonym = (Synonym) taxonBase;

//			HomotypicalSynonymGroup group = new HomotypicalSynonymGroup(this, synonym.getHomotypicGroup());

//			

//			new SynonymContainer(this, group, (Synonym) taxonBase);

//		}

//		else if(target instanceof MisappliedGroup){

//			Taxon taxon = (Taxon) taxonBase;

//			

//			if (taxon.isMisapplication()){

//				containerFactory.createMisapplication(this, taxon);

//			}else if(! taxon.equals(this.taxon)){

//				throw new RuntimeException("Unsupported operands");

//			}

//		}

	}

	/**

	 * <p>getNameEditor</p>

	 *

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

	 */

	public TaxonNameEditor getNameEditor() {

		return this;

	}

	/**

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

	 *

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

	 */

	public AbstractGroupedContainer getSelectedObject(){

		TaxonEditorInput input = (TaxonEditorInput) editor.getEditorInput();

		if(input.getInitiallySelectedTaxonBase() != null){

			TaxonBase initiallySelectedTaxonBase = input.getInitiallySelectedTaxonBase();

			AbstractGroupedContainer container = getContainerForData(initiallySelectedTaxonBase);

			if(container != null){

				input.setInitiallySelectedTaxonBase(null);

				return container;

			}

		}else{

			if(selectedObject != null){

				return selectedObject;

			}

		}

		return acceptedNameContainer;

	}

	/**

	 * <p>dragEntered</p>

	 */

	public void dragEntered() {

		// TODO change this

		getControl().setBackground(EditorUtil.getColor(Resources.COLOR_DRAG_ENTER));

	}

	/**

	 * <p>dragLeft</p>

	 */

	public void dragLeft() {

		getControl().setBackground(EditorUtil.getColor(Resources.COLOR_COMPOSITE_BACKGROUND));

	}

	/**

	 * <p>Setter for the field <code>conceptGroup</code>.</p>

	 *

	 * @param conceptGroup a {@link eu.etaxonomy.taxeditor.editor.name.ConceptGroup} object.

	 */

	public void setConceptGroup(ConceptGroup conceptGroup) {

		this.conceptGroup = conceptGroup;

	}

	/**

	 * <p>setMisapplicationsGroup</p>

	 *

	 * @param misappliedGroup a {@link eu.etaxonomy.taxeditor.editor.name.MisappliedGroup} object.

	 */

	public void setMisapplicationsGroup(MisappliedGroup misappliedGroup) {

		this.misappliedGroup = misappliedGroup;

	}

	/*

	 * (non-Javadoc)

	 * @see eu.etaxonomy.taxeditor.editor.IMultiPageTaxonEditorPage#isRedrawing()

	 */

	/**

	 * <p>isRedrawing</p>

	 *

	 * @return a boolean.

	 */

	public boolean isRedrawing() {

		return false;

	}

	/**

	 * <p>getToolkit</p>

	 *

	 * @return a {@link org.eclipse.ui.forms.widgets.FormToolkit} object.

	 */

	public FormToolkit getToolkit() {

		return managedForm.getToolkit();

	}

	/**

	 * <p>getHeterotypicSynonymGroups</p>

	 *

	 * @return a {@link java.util.List} object.

	 */

	public List<HomotypicalSynonymGroup> getHeterotypicSynonymGroups(){

		List<HomotypicalSynonymGroup> list = new ArrayList<HomotypicalSynonymGroup>(heterotypicSynonymGroupTupel.size());

		for(Tupel tupel : heterotypicSynonymGroupTupel){

			list.add(tupel.group);

		}

		return list;

	}

	/**

	 * <p>getHeterotypicSynonymGroupsMap</p>

	 *

	 * @return a {@link java.util.Map} object.

	 */

	public Map<HomotypicalGroup, HomotypicalSynonymGroup> getHeterotypicSynonymGroupsMap(){

		Map<HomotypicalGroup, HomotypicalSynonymGroup> map = new HashMap<HomotypicalGroup, HomotypicalSynonymGroup>(heterotypicSynonymGroupTupel.size());

		for(Tupel tupel : heterotypicSynonymGroupTupel){

			map.put(tupel.homotypicalGroup, tupel.group);

		}

		return map;

	}

	/**

	 * <p>clearHeterotypicSynonymGroups</p>

	 */

	public void clearHeterotypicSynonymGroups(){

		heterotypicSynonymGroupTupel.clear();

	}

	/**

	 * <p>addHeterotypicSynonymGroup</p>

	 *

	 * @param group a {@link eu.etaxonomy.taxeditor.editor.name.HomotypicalSynonymGroup} object.

	 */

	public void addHeterotypicSynonymGroup(HomotypicalSynonymGroup group) {

		heterotypicSynonymGroupTupel.add(new Tupel(group.getGroup(), group));

	}

	/**

	 * <p>removeHeterotypicSynonymGroup</p>

	 *

	 * @param group a {@link eu.etaxonomy.cdm.model.name.HomotypicalGroup} object.

	 */

	public void removeHeterotypicSynonymGroup(HomotypicalGroup group) {

		Tupel shouldBeRemoved = null;

		for(Tupel tupel : heterotypicSynonymGroupTupel){

			if(tupel.group.equals(group)){

				shouldBeRemoved = tupel;

				break;

			}			

		}

		if(shouldBeRemoved != null){

			heterotypicSynonymGroupTupel.remove(shouldBeRemoved);

		}

	}

	/**

	 * <p>getHomotypicSynonymGroup</p>

	 *

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

	 */

	public HomotypicalSynonymGroup getHomotypicSynonymGroup() {

		return homotypicalSynonymGroup;

	}

	/**

	 * <p>setHomotypicSynonymGroup</p>

	 *

	 * @param homotypicalSynonymGroup a {@link eu.etaxonomy.taxeditor.editor.name.HomotypicalSynonymGroup} object.

	 */

	public void setHomotypicSynonymGroup(

			HomotypicalSynonymGroup homotypicalSynonymGroup) {

		this.homotypicalSynonymGroup = homotypicalSynonymGroup;

	}

	/**

	 * <p>Setter for the field <code>acceptedNameContainer</code>.</p>

	 *

	 * @param acceptedNameContainer a {@link eu.etaxonomy.taxeditor.editor.name.AcceptedNameContainer} object.

	 */

	public void setAcceptedNameContainer(

			AcceptedNameContainer acceptedNameContainer) {

		this.acceptedNameContainer = acceptedNameContainer;		

	}

	/**

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

	 *

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

	 */

	public MisappliedGroup getMisappliedGroup() {

		return misappliedGroup;

	}

	// TODO not very useful at the moment

	/**

	 * <p>isActive</p>

	 *

	 * @return a boolean.

	 */

	public boolean isActive(){

		IWorkbenchPart activePart = EditorUtil.getActivePart();

		return editor.equals(activePart);

	}

	/**

	 * <p>onComplete</p>

	 *

	 * @return a boolean.

	 */

	public boolean onComplete() {

		objectAffectedByLastOperation.setSelected();

		return true;

	}

	/** {@inheritDoc} */

	public void partChanged(Integer eventType, IWorkbenchPartReference partRef) {

		if(! partRef.getPart(false).equals(editor)){

			getSelectedObject().colorSelected(AbstractGroupedContainer.SELECTED_NO_FOCUS);

		}

	}

}