EDIT

/**

* Copyright (C) 2017 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.termtree.e4;

import java.util.HashMap;

import java.util.Map;

import java.util.UUID;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.DragSourceListener;

import org.eclipse.swt.dnd.DropTargetListener;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.events.ModifyListener;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Text;

import org.eclipse.swt.widgets.Tree;

import eu.etaxonomy.cdm.api.service.ITermTreeService;

import eu.etaxonomy.cdm.model.term.DefinedTermBase;

import eu.etaxonomy.cdm.model.term.TermTree;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.cdm.persistence.dto.TermNodeDto;

import eu.etaxonomy.cdm.persistence.dto.TermTreeDto;

import eu.etaxonomy.taxeditor.editor.definedterm.TermTransfer;

import eu.etaxonomy.taxeditor.l10n.Messages;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.ImageResources;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.StoreUtil;

import eu.etaxonomy.taxeditor.termtree.CharacterNodeDtoTransfer;

import eu.etaxonomy.taxeditor.termtree.TermTreeContentProvider;

import eu.etaxonomy.taxeditor.termtree.TermTreeLabelProvider;

import eu.etaxonomy.taxeditor.ui.dialog.selection.FeatureTreeSelectionDialog;

/**

 * @author pplitzner

 * @since Jun 19, 2017

 */

public class TermTreeDtoEditorComposite <T extends DefinedTermBase> extends Composite{

    private TermTreeDto featureTree;

    private Label label_title;

    private Text text_title;

    private Button btnOpenFeatureTree;

    private TreeViewer viewer;

    private Map<UUID, TermNodeDto> nodeUuidMap = new HashMap<>();

    public TermTreeDtoEditorComposite(Composite parent, int style) {

        super(parent, style);

        setLayout(new GridLayout(1, false));

        Composite composite_treeTitle = new Composite(this, SWT.NULL);

        composite_treeTitle.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true,

                false));

        GridLayout gl_composite_treeTitle = new GridLayout(3, false);

        gl_composite_treeTitle.marginWidth = 0;

        composite_treeTitle.setLayout(gl_composite_treeTitle);

        label_title = new Label(composite_treeTitle, SWT.NULL);

        label_title.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));

        label_title.setText(Messages.TermTreeEditorComposite_FEATURE_TREE);

        text_title = new Text(composite_treeTitle, SWT.BORDER);

        text_title.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));

        text_title.setEditable(false);

        btnOpenFeatureTree = new Button(composite_treeTitle, SWT.NONE);

        btnOpenFeatureTree.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, false, 1, 1));

        btnOpenFeatureTree.setToolTipText(Messages.TermTreeEditorComposite_OPEN_TREE);

        btnOpenFeatureTree.setImage(ImageResources.getImage(ImageResources.BROWSE_ICON));

        viewer = new TreeViewer(new Tree(this, SWT.H_SCROLL | SWT.V_SCROLL | SWT.MULTI));

        Tree tree = viewer.getTree();

        tree.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 3, 1));

        viewer.getControl().setLayoutData(

                new GridData(SWT.FILL, SWT.FILL, true, true));

    }

    public void init(String label,

            DragSourceListener dragSourceListener,

            DropTargetListener dropTargetListener,

            ISelectionChangedListener viewerSelectionChangedListener,

            IDirtyMarkable dirtyMarkable,

            ModifyListener textModifyListener) {

        init(label,

                null,

                dragSourceListener,

                dropTargetListener,

                null,

                viewerSelectionChangedListener,

                null,

                dirtyMarkable,

                textModifyListener);

    }

    public void init(String label, TermType termType,

            DragSourceListener dragSourceListener,

            DropTargetListener dropTargetListener,

            ISelectionChangedListener viewerSelectionChangedListener,

            IDirtyMarkable dirtyMarkable,

            ModifyListener textModifyListener) {

        this.init(label,

                termType,

                dragSourceListener,

                dropTargetListener,

                null,

                viewerSelectionChangedListener,

                null,

                dirtyMarkable,

                textModifyListener);

    }

    public void init(DragSourceListener dragSourceListener,

            DropTargetListener dropTargetListener,

            Transfer[] transfers,

            ISelectionChangedListener viewerSelectionChangedListener,

            SelectionListener openFeatureTreeSelectionListener,

            ModifyListener textModifyListener) {

        init(null,

                null,

                dragSourceListener,

                dropTargetListener,

                transfers,

                viewerSelectionChangedListener,

                openFeatureTreeSelectionListener,

                null,

                textModifyListener);

    }

    private void init(String label,

            TermType termType,

            DragSourceListener dragSourceListener,

            DropTargetListener dropTargetListener,

            Transfer[] transfers,

            ISelectionChangedListener viewerSelectionChangedListener,

            SelectionListener openFeatureTreeSelectionListener,

            IDirtyMarkable dirtyMarkable,

            ModifyListener textModifyListener) {

        if(label!=null){

            label_title.setText(label);

        }

        viewer.setContentProvider(new TermTreeContentProvider());

        viewer.setLabelProvider(new TermTreeLabelProvider());

        int ops = DND.DROP_COPY | DND.DROP_MOVE;

        if(transfers==null){

        transfers = new Transfer[] {

                CharacterNodeDtoTransfer.getInstance(),

                TermTransfer.getInstance(),

                };

        }

        if(dragSourceListener!=null){

            viewer.addDragSupport(ops, transfers, dragSourceListener);

        }

        if(dropTargetListener!=null){

            viewer.addDropSupport(ops, transfers, dropTargetListener);

        }

        if(viewerSelectionChangedListener!=null){

            viewer.addSelectionChangedListener(viewerSelectionChangedListener);

        }

        if(textModifyListener!=null){

            text_title.addModifyListener(textModifyListener);

        }

        //add specific selection listener

        if(openFeatureTreeSelectionListener!=null){

            btnOpenFeatureTree.addSelectionListener(openFeatureTreeSelectionListener);

        }

        else{

            //add default selection listener

            btnOpenFeatureTree.addSelectionListener(new SelectionAdapter(){

                @Override

                public void widgetSelected(SelectionEvent e) {

                    TermTree<T> tree = FeatureTreeSelectionDialog.select(getDisplay().getActiveShell(),

                            null, termType);

                    if(tree!=null){

                        setSelectedTree(tree);

                        if(dirtyMarkable!=null){

                            dirtyMarkable.forceDirty();

                        }

                    }

                }

            });

        }

    }

    public void setSelectedTree(TermTree<T> featureTree) {

        this.featureTree = CdmStore.getService(ITermTreeService.class).getTermTreeDtoByUuid(featureTree.getUuid());

        addChildNodesToMap(this.featureTree.getRoot());

        viewer.setInput(this.featureTree);

        StoreUtil.setTextWithoutModifyListeners(text_title, featureTree!=null?featureTree.getTitleCache():"");

    }

    private void addChildNodesToMap(TermNodeDto root) {

        this.nodeUuidMap.put(root.getUuid(), root);

        if (root.getTerm() != null){

            this.featureTree.addTerm(root.getTerm());

        }

        for (TermNodeDto child: root.getChildren()){

            addChildNodesToMap(child);

        }

    }

 public TermTreeDto getFeatureTree() {

        return featureTree;

    }

    public Label getLabel_title() {

        return label_title;

    }

    public Button getBtnOpenFeatureTree() {

        return btnOpenFeatureTree;

    }

    public TreeViewer getViewer() {

        return viewer;

    }

    public Map<UUID, TermNodeDto> getNodeUuidMap() {

        return nodeUuidMap;

    }

    public void setNodeUuidMap(Map<UUID, TermNodeDto> nodeUuidMap) {

        this.nodeUuidMap = nodeUuidMap;

    }

    /**

     *

     */

    public void refresh() {

        getViewer().setInput(getViewer().getInput());

        addChildNodesToMap(this.featureTree.getRoot());

    }

}