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

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import org.apache.commons.lang.StringUtils;

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

import org.eclipse.core.runtime.OperationCanceledException;

import org.eclipse.e4.ui.di.Persist;

import org.eclipse.e4.ui.workbench.modeling.EPartService;

import org.eclipse.jface.viewers.ISelectionProvider;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.swt.dnd.DropTarget;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.ui.ISelectionListener;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.IWorkbenchPartReference;

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 eu.etaxonomy.cdm.api.conversation.ConversationHolder;

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.name.e4.container.AbstractGroupE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.AbstractGroupedContainerE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.AcceptedGroupE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.AcceptedNameContainerE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.HomotypicalSynonymGroupE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.MisappliedGroupE4;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartChangeListener;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasMedia;

import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;

import eu.etaxonomy.taxeditor.preference.Resources;

import eu.etaxonomy.taxeditor.security.RequiredPermissions;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 *

 * @author pplitzner

 * @date Aug 24, 2017

 *

 */

        IPartContentHasSupplementalData, IPartContentHasMedia, IPartContentHasFactualData, IPartChangeListener,

    private ScrolledForm scrolledForm;

    private Composite parent;

    private ISelectionProvider simpleSelectionProvider;

    private List<HomotypicalSynonymGroupE4> heterotypicSynonymGroups = new ArrayList<>();

    private MisappliedGroupE4 misappliedGroup;

    UISynchronize sync;

    private EMenuService menuService;

    private ESelectionService selService;

    private IEclipseContext context;

    private MDirtyable dirty;

    private MApplication application;

    private IEventBroker eventBroker;

    public TaxonNameEditorE4() {

        undoContext = new UndoContext();

    }

            public void dirtyStateChanged() {

                dirty.setDirty(true);

            }

            public boolean setInput(Object input) {

                if (input instanceof AbstractGroupedContainerE4) {

                    TaxonBase newSelection = ((AbstractGroupedContainerE4) input).getData();

                    if (selection != newSelection || TaxonNameEditorE4.this.isDirty()) {

                        selection = newSelection;

                        selService.setSelection(new StructuredSelection(selection));

                    }

                } else if (input == null) {

                    selection = null;

            }

        };

        parent = scrolledForm.getBody();

        layout.leftMargin = 0;

        layout.rightMargin = 0;

        layout.topMargin = 0;

        layout.bottomMargin = 0;

        layout.horizontalSpacing = 0;

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

    }

        }

        }

        }

        ContainerFactoryE4.setMenuToAllContainers(this);

        parent.pack();

        managedForm.refresh();

        managedForm.reflow(true);

    }

        managedForm.dirtyStateChanged();

    }

    public void setFocus() {

        // make sure to bind again if maybe in another view the conversation was

        // unbound

        if (conversation != null && !conversation.isBound()) {

        }

            if (getSelectedContainer() == null) {

                throw new IllegalStateException(Messages.TaxonNameEditor_THERE_SHOULD_ALWAYS_BE);

            }

            getSelectedContainer().setSelected();

                input.bind();

            }

            // check permissions

            boolean doEnable = permissionsSatisfied();

            managedForm.getForm().setEnabled(doEnable);

        }

            selService.setSelection(new StructuredSelection(selection));

        }

    public boolean permissionsSatisfied() {

        TaxonNode taxonNode = input.getTaxonNode();

        boolean doEnable = CdmStore.currentAuthentiationHasPermission(taxonNode.getTaxon(),

                RequiredPermissions.TAXON_EDIT);

        return doEnable;

    }

    }

    @Override

    }

    /**

     * Redraws this editor return true on success

     *

     * @return a boolean.

     */

    }

    /**

     * {@inheritDoc}

     *

     * Redraws the editor controls

     */

            setFocus();

        }

    }

            objectAffectedByLastOperation = (TaxonBase) objectAffectedByOperation;

        }

        changed(objectAffectedByOperation);

    }

    public ManagedForm getManagedForm() {

        return managedForm;

    }

    /**

     * <p>

     * checkForEmptyNames

     * </p>

     *

     * @return true if there are empty names

     */

    public boolean checkForEmptyNames() {

        for (AbstractGroupedContainerE4 container : getGroupedContainers()) {

            if (container != null

                    && (container.getName() == null || StringUtils.isEmpty(container.getName().getTitleCache()))) {

                return true;

            }

        }

        return false;

    }

    public Set<AbstractGroupedContainerE4> getEmptyContainers() {

        Set<AbstractGroupedContainerE4> containersWithEmptyNames = new HashSet<>();

        for (AbstractGroupedContainerE4 container : getGroupedContainers()) {

            if (container.getName() == null || StringUtils.isEmpty(container.getName().getTitleCache())) {

                containersWithEmptyNames.add(container);

            }

        }

        return containersWithEmptyNames;

    }

    @Override

        monitor.beginTask(Messages.TaxonNameEditor_SAVING_NAMES, getGroupedContainers().size());

        if (!conversation.isBound()) {

            conversation.bind();

        }

        // check for empty names

        if (checkForEmptyNames()) {

            MessageDialog.openWarning(AbstractUtility.getShell(), Messages.MultiPageTaxonEditor_NO_NAME_SPECIFIED,

                    Messages.MultiPageTaxonEditor_NO_NAME_SPECIFIED_MESSAGE);

            return;

        }

        for (AbstractGroupedContainerE4 container : getGroupedContainers()) {

            monitor.subTask(Messages.TaxonNameEditor_SAVING_COMPOSITES + container.getTaxonBase().getTitleCache());

            container.persistName();

            // because of missing cascading the concepts need to be saved

            // separately

            if (container instanceof ConceptContainerE4) {

                input.addToSaveNewConcept((Taxon) container.getData());

            }

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

            if (monitor.isCanceled()) {

                throw new OperationCanceledException();

            }

            monitor.worked(1);

        }

        input.setSync(sync);

        input.merge();

        // commit the conversation and start a new transaction immediately

        conversation.commit(true);

        dirty.setDirty(false);

        monitor.done();

    }

    public void init(TaxonEditorInputE4 input) {

        if (this.input != null) {

            this.input.dispose();

            // this.acceptedGroup = null;

            // this.heterotypicSynonymGroups.clear();

            // this.misappliedGroup = null;

        }

        if (!(input != null)) {

            return;

            taxon = CdmBase.deproxy(input.getAdapter(Taxon.class), Taxon.class);

        } else {

            MessagingUtils.error(this.getClass(), new Exception(Messages.TaxonNameEditor_INVALID_INPUT_TAXON_NULL));

            return;

        }

        conversation = input.getConversationHolder();

            getContainer(initiallySelectedTaxonBase).setSelected();

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

        }

    }

    public AcceptedNameContainerE4 getAcceptedNameContainer() {

        return getAcceptedGroup().getAcceptedNameContainer();

    }

    public HomotypicalSynonymGroupE4 getHomotypicalGroupContainer(HomotypicalGroup homotypicalGroup) {

        for (HomotypicalSynonymGroupE4 group : getHeterotypicSynonymGroups()) {

            if (group.getGroup().equals(homotypicalGroup)) {

                return group;

            }

        }

        return null;

    }

    /**

     * <p>

     * getDirtyNames

     * </p>

     *

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

     */

    public Set<AbstractGroupedContainerE4> getDirtyNames() {

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

        for (AbstractGroupedContainerE4 composite : getGroupedContainers()) {

            if (composite.isDirty()) {

                dirtyNames.add(composite);

            }

        }

        return dirtyNames;

    }

    public List<AbstractGroupedContainerE4> getGroupedContainers() {

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

        for (AbstractGroupE4 group : getAllGroups()) {

            if (group != null) {

                groupedComposites.addAll(group.getGroupedContainers());

            }

        }

        return groupedComposites;

    }

    public List<AbstractGroupE4> getAllGroups() {

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

        allGroups.add(getAcceptedGroup());

        heterotypicSynonymGroups = getHeterotypicSynonymGroups();

        if (heterotypicSynonymGroups != null) {

            allGroups.addAll(heterotypicSynonymGroups);

        }

        if (misappliedGroup != null) {

            allGroups.add(misappliedGroup);

        }

        return allGroups;

    }

    @Override

    public IEclipseContext getContext() {

        return context;

    }

    @Override

    }

    public void dispose() {

        if (conversation != null) {

            conversation.close();

        }

        }

    @Override

    }

        return (selection != null) ? getContainer(selection) : getAcceptedNameContainer();

    }

    public void dragEntered() {

        // TODO change this

    @Override

    public void dragLeft() {

        this.misappliedGroup = misappliedGroup;

    }

        return managedForm.getToolkit();

    }

        return heterotypicSynonymGroups;

    }

        heterotypicSynonymGroups.add(group);

    }

        return acceptedGroup;

    }

        this.acceptedGroup = acceptedGroup;

    }

        return misappliedGroup;

    }

        return this.equals(AbstractUtility.getActivePart());

    }

    @Override

    public boolean onComplete() {

        return true;

    }

    @Override

            // getSelectedObject().colorSelected(AbstractGroupedContainer.SELECTED_NO_FOCUS);

        }

    }

    public void removeGroup(AbstractGroupE4 group) {

        if (group != null) {

            group.dispose();

            // if (heterotypicSynonymGroups != null) {

            heterotypicSynonymGroups.remove(group);

            // }

        }

    }

    public AbstractGroupedContainerE4 getContainer(TaxonBase taxonBase) {

        @SuppressWarnings("rawtypes")

            if (container.getData().equals(taxonBase) && container.getNameViewer().getTextWidget() != null) {

                return container;

            }

        }

        return getAcceptedNameContainer();

    }

    public void setOnError() {

        setEnabled(false, disabledColor);

    }

        Color disabledColor = AbstractUtility.getColor(Resources.COLOR_TEXT_DISABLED_BACKGROUND);

        setEnabled(false, disabledColor);

    }

            groupedContainer.setEnabled(enabled);

        }

        // ???

        if (!enabled) {

            getManagedForm().setInput(null);

                groupedContainer.setBackground(background);

            }

        }

        getControl().setBackground(background);

    }

    @Override

    public void changed(Object element) {

        // the problem that for tasks done in service methods the changes are

        // saved automatically

        if (element != null) {

            // TODO: refresh taxon node in taxon navigator

            AbstractGroupedContainerE4 container = getContainer((TaxonBase) element);

            if (container != null) {

                container.refresh();

            }

        }

            AbstractGroupedContainerE4 container = getContainer(((TaxonRelationship) element).getFromTaxon());

            if (container != null) {

                container.refresh();

            }

        }

        // FIXME: temporary fix for #6437 to avoid outdated title caches

    @Override

    public void forceDirty() {

        setDirty();

    }

    public IUndoContext getUndoContext() {

    }

        return menuService;

    }