EDIT

import eu.etaxonomy.taxeditor.featuretree.CharacterTransfer;

import eu.etaxonomy.taxeditor.featuretree.e4.TermNodeDragListener;

import eu.etaxonomy.taxeditor.featuretree.CharacterTransfer;

import eu.etaxonomy.taxeditor.featuretree.e4.TermTreeDtoDropAdapter;

import eu.etaxonomy.taxeditor.featuretree.CharacterTransfer;

import eu.etaxonomy.taxeditor.featuretree.TermTreeContentProvider;

import eu.etaxonomy.taxeditor.featuretree.TermTreeLabelProvider;

import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeDtoEditorComposite;

import eu.etaxonomy.taxeditor.featuretree.e4.ICharacterEditor;

import eu.etaxonomy.taxeditor.featuretree.e4.TermNodeDtoDragListener;

import eu.etaxonomy.taxeditor.featuretree.e4.TermTreeDtoDropAdapter;

import eu.etaxonomy.taxeditor.featuretree.e4.TermTreeEditor;

    private FeatureTreeDtoEditorComposite characterTreeEditorComposite;

    private <T extends DefinedTermBase> FeatureTreeDtoEditorComposite<T> addFeatureTreeEditor(Composite composite_3) {

        FeatureTreeDtoEditorComposite<T> TermTreeEditorComposite = new FeatureTreeDtoEditorComposite<>(composite_3, SWT.NONE);

            FeatureTreeDtoEditorComposite TermTreeEditorComposite,

        private FeatureTreeDtoEditorComposite<Feature> TermTreeEditorComposite;

        public FeatureTreeChooserListener(FeatureTreeDtoEditorComposite<Feature> TermTreeEditorComposite, TermType termType) {

import eu.etaxonomy.taxeditor.featuretree.e4.handler.AddTermHandler;

                        String.format("The common parent taxon of this data set is :\n%s\n\n"

        String jobLabel = "Aggregate Descriptive Data Set";

import eu.etaxonomy.taxeditor.featuretree.TermTreeLabelProvider;

import eu.etaxonomy.taxeditor.featuretree.TermChooseWizard;

/**

* 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.featuretree;

import java.util.List;

import java.util.Set;

import org.eclipse.jface.wizard.Wizard;

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

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

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

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

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * <p>AvailableFeaturesWizard class.</p>

 *

 * @author n.hoffmann

 * @created Aug 5, 2010

 * @version 1.0

 */

public class AvailableTermsWizard extends Wizard {

	private AvailableTermsWizardPage page;

	private Set<DefinedTermBase> additionalFeatures;

    private List<TermVocabularyDto> vocabularyDtos;

    private boolean singleSelection = false;

	public AvailableTermsWizard(TermType termType){

        vocabularyDtos = CdmStore.getService(IVocabularyService.class).findVocabularyDtoByTermType(termType);

	}

	public AvailableTermsWizard(List<TermVocabularyDto> vocabularyDtos){

	    this.vocabularyDtos = vocabularyDtos;

	}

	/** {@inheritDoc} */

	@Override

	public void addPages() {

		page = new AvailableTermsWizardPage(vocabularyDtos,singleSelection);

		addPage(page);

	}

	@Override

	public boolean canFinish() {

        int size = page.getSelectedFeatures().size();

        return singleSelection?size==1:size>0;

	}

	/** {@inheritDoc} */

	@Override

	public boolean performFinish() {

		additionalFeatures = page.getSelectedFeatures();

		if(singleSelection && additionalFeatures.size()>1){

		    MessagingUtils.warningDialog("Too many terms selected", this, "You can only select 1 term");

		}

		return additionalFeatures.size() > 0;

	}

	public Set<DefinedTermBase> getAdditionalFeatures() {

		return additionalFeatures;

	}

    public void setSingleSelection(boolean singleSelection) {

        this.singleSelection = singleSelection;

    }

}

/**

* 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.featuretree;

import java.util.Arrays;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.stream.Collectors;

import org.eclipse.jface.wizard.WizardPage;

import org.eclipse.swt.SWT;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.widgets.Composite;

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

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.preference.wizard.CheckBoxTreeComposite;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * @author n.hoffmann

 * @created Aug 5, 2010

 * @version 1.0

 */

public class AvailableTermsWizardPage extends WizardPage {

    private CheckBoxTreeComposite treeComposite;

    private List<TermVocabularyDto> vocabularies;

	protected AvailableTermsWizardPage(List<TermVocabularyDto> vocabularies, boolean singleSelection) {

		super("Available Terms Wizard Page");

		this.vocabularies = vocabularies;

		setTitle("Available Terms");

		if(singleSelection){

		    setDescription("Please select one single term");

		}

		else{

		    setDescription("Please select terms.");

		}

	}

	/** {@inheritDoc} */

	@Override

	public void createControl(Composite parent) {

        treeComposite = new CheckBoxTreeComposite(parent, new TermDtoContentProvider(), new TermDtoLabelProvider(), SWT.NONE);

        treeComposite.getViewer().setComparator(new DefinedTermSorter());

        treeComposite.getViewer().setInput(vocabularies);

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

        treeComposite.getViewer().addSelectionChangedListener(e->getWizard().getContainer().updateButtons());

		setControl(treeComposite);

	}

	public Set<DefinedTermBase> getSelectedFeatures() {

        List<Object> checkedElements = Arrays.asList(treeComposite.getViewer().getCheckedElements());

        checkedElements = checkedElements.stream().filter(element->element instanceof TermDto).collect(Collectors.toList());

		Set<DefinedTermBase> terms = new HashSet<>();

		for(Object element : checkedElements){

		    if(element instanceof TermDto){

		        DefinedTermBase term = CdmStore.getService(ITermService.class).load(((TermDto) element).getUuid());

		        terms.add(term);

		    }

		}

		return terms;

	}

}

/**

* Copyright (C) 2020 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.featuretree;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.EOFException;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import java.util.UUID;

import org.eclipse.swt.SWTException;

import org.eclipse.swt.dnd.ByteArrayTransfer;

import org.eclipse.swt.dnd.TransferData;

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * @author k.luther

 * @since Oct 13, 2020

 */

public class CharacterNodeDtoTransfer extends ByteArrayTransfer {

    private static CharacterNodeDtoTransfer instance = new CharacterNodeDtoTransfer();

    private static final String TYPE_NAME = "featureNodeDto-transfer-format";

    private static final int TYPEID = registerType(TYPE_NAME);

    /**

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

     *

     * @return a {@link eu.etaxonomy.taxeditor.featuretree.FeatureNodeTransfer} object.

     */

    public static synchronized CharacterNodeDtoTransfer getInstance() {

        return instance;

    }

    private CharacterNodeDtoTransfer() {

    }

    /** {@inheritDoc} */

    @Override

    protected int[] getTypeIds() {

        return new int[] { TYPEID };

    }

    /** {@inheritDoc} */

    @Override

    protected String[] getTypeNames() {

        return new String[] { TYPE_NAME };

    }

    @Override

    protected void javaToNative(Object object, TransferData transferData) {

        if (object != null){

            byte[] bytes = toByteArray((TermNodeDto[]) object);

            if (bytes != null) {

                super.javaToNative(bytes, transferData);

            }

        }

    }

    @Override

    protected Object nativeToJava(TransferData transferData) {

        try{

            byte[] bytes = (byte[]) super.nativeToJava(transferData);

            if (bytes != null){

                return fromByteArray(bytes);

            }

        }catch (SWTException e){

            MessagingUtils.warningDialog("The new imported node needs to be saved first", this, "Newly created nodes can not be moved without saving");

        }

        return null;

    }

    protected byte[] toByteArray(TermNodeDto[] elements) {

        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();

        DataOutputStream out = new DataOutputStream(byteOut);

        byte[] bytes = null;

        try {

            for(TermNodeDto element : elements){

                if (element.getUuid() == null){

                //  MessagingUtils.warningDialog("The new imported node needs to be saved first", this, "Newly created nodes can not be moved without saving");

                }else{

                    writeElementUuid(element, out);

                }

            }

            out.close();

            bytes = byteOut.toByteArray();

        } catch (IOException e) {

            // when in doubt send nothing

        }

        return bytes;

    }

    protected Object[] fromByteArray(byte[] bytes) {

        DataInputStream in = new DataInputStream(

                new ByteArrayInputStream(bytes));

        try {

            List<CharacterNodeDto> elements = new ArrayList<CharacterNodeDto>();

            try{

                while(true){

                    UUID uuid = readElementUuid(in);

                    elements.add(loadElement(uuid));

                }

            }catch(EOFException e){

                return  elements.toArray();

            }

        } catch (IOException e) {

            return null;

        }

    }

    public CharacterNodeDto loadElement(UUID uuid){

        TermNode node = CdmStore.getService(ITermNodeService.class).load(uuid);

        TermTreeDto tree = TermTreeDto.fromTree((TermTree)node.getGraph());

        return CharacterNodeDto.fromTermNode(node, tree);

    }

    public UUID readElementUuid(DataInputStream in) throws IOException{

        return UUID.fromString(in.readUTF());

    }

    private void writeElementUuid(TermNodeDto element, DataOutputStream out) throws IOException {

        out.writeUTF(element.getUuid().toString());

    }

}

/**

* Copyright (C) 2018 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.featuretree;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.EOFException;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import java.util.UUID;

import org.eclipse.swt.dnd.ByteArrayTransfer;

import org.eclipse.swt.dnd.TransferData;

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

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

import eu.etaxonomy.cdm.model.description.Character;

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

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

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

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * @author pplitzner

 * @since Nov 30, 2018

 *

 */

public class CharacterTransfer extends ByteArrayTransfer {

    private static CharacterTransfer instance = new CharacterTransfer();

    private static final String TYPE_NAME = "characters-transfer-format";

    private static final int TYPEID = registerType(TYPE_NAME);

    public static synchronized CharacterTransfer getInstance() {

        return instance;

    }

    private CharacterTransfer() {

    }

    @Override

    protected int[] getTypeIds() {

        return new int[] { TYPEID };

    }

    @Override

    protected String[] getTypeNames() {

        return new String[] { TYPE_NAME };

    }

    @Override

    protected void javaToNative(Object object, TransferData transferData) {

        if (object != null){

            Collection<Character> characters = (Collection<Character>)object;

            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();

            DataOutputStream out = new DataOutputStream(byteOut);

            byte[] bytes = null;

            try {

                for(Character character : characters){

                    out.writeUTF(character.getStructure().getUuid().toString()

                            +","

                            +character.getProperty().getUuid().toString());

                }

                out.close();

                bytes = byteOut.toByteArray();

            } catch (IOException e) {

                // when in doubt send nothing

            }

            if (bytes != null) {

                super.javaToNative(bytes, transferData);

            }

        }

    }

    @Override

    protected Object nativeToJava(TransferData transferData) {

        byte[] bytes = (byte[]) super.nativeToJava(transferData);

        if (bytes != null){

            DataInputStream in = new DataInputStream(

                    new ByteArrayInputStream(bytes));

            try {

                List<Character> characters = new ArrayList<>();

                try{

                    while(true){

                        String string = in.readUTF();

                        String[] split = string.split(",");

                        IFeatureNodeService featureNodeService = CdmStore.getService(IFeatureNodeService.class);

                        TermNode<DefinedTerm> structure = featureNodeService.load(UUID.fromString(split[0]));

                        TermNode<DefinedTerm> property = featureNodeService.load(UUID.fromString(split[1]));

                        characters.add(createCharacter(structure, property));

                    }

                }catch(EOFException e){

                    return characters.toArray();

                }

            } catch (IOException e) {

                return null;

            }

        }

        return null;

    }

    public static Character createCharacter(TermNode<DefinedTerm> structureNode,

            TermNode<DefinedTerm> propertyNode) {

        Representation structureRepresentation = structureNode.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());

        if(structureRepresentation==null){

            structureRepresentation = structureNode.getTerm().getRepresentation(Language.DEFAULT());

        }

        Representation propertyRepresentation = propertyNode.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());

        if(propertyRepresentation==null){

            propertyRepresentation = propertyNode.getTerm().getRepresentation(Language.DEFAULT());

        }

        String label = null;

        String abbrevLabel = null;

        if(structureRepresentation!=null && propertyRepresentation!=null){

            if(structureRepresentation.getLabel()!=null && propertyRepresentation.getLabel()!=null){

                label = structureRepresentation.getLabel()+" "+propertyRepresentation.getLabel();

            }

            if(structureRepresentation.getAbbreviatedLabel()!=null && propertyRepresentation.getAbbreviatedLabel()!=null){

                abbrevLabel = structureRepresentation.getAbbreviatedLabel()+" "+propertyRepresentation.getAbbreviatedLabel();

            }

        }

        if(label!=null){

            //default label

            label = structureNode.getTerm().getLabel()+" "+propertyNode.getTerm().getLabel();

        }

        //create new Character

        Character character = Character.NewInstance(structureNode, propertyNode, null, label, abbrevLabel);

        return character;

    }

}

/**

* 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.featuretree;

import java.util.List;

import org.eclipse.jface.wizard.Wizard;

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

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

/**

 *

 * @author pplitzner

 * @since Feb 14, 2019

 *

 */

public class TermChooseWizard extends Wizard {

	private TermChooseWizardPage page;

	private List<AbstractTermDto> selectedTerms;

    private TermDto term;

	public TermChooseWizard(TermDto term){

	    this.term = term;

	}

    public List<AbstractTermDto> getSelectedTerms() {

        return selectedTerms;

    }

	@Override

	public void addPages() {

		page = new TermChooseWizardPage(term);

		page.setPageComplete(false);

		addPage(page);

	}

	@Override

	public boolean performFinish() {

		selectedTerms = page.getSelectedTerms();

		return selectedTerms.size() > 0;

	}

}

/**

* 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.featuretree;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.jface.wizard.WizardPage;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

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

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

import eu.etaxonomy.taxeditor.view.search.facet.SearchComposite;

import eu.etaxonomy.taxeditor.view.search.facet.term.TermSearchController;

/**

 * @author pplitzner

 * @since Feb 14, 2019

 */

public class TermChooseWizardPage extends WizardPage {

    private TermSearchController controller;

    private TermDto term;

	protected TermChooseWizardPage(TermDto term) {

		super("Term Choose Wizard");

		setTitle("Choose Parent");

		setDescription("Please search and select the parent term or vocabulary (if you want to move the term as root).");

		this.term = term;

	}

	@Override

	public void createControl(Composite parent) {

        SearchComposite searchComposite = new SearchComposite(parent, SWT.NONE);

        controller = new TermSearchController(searchComposite, term, this);

		setControl(searchComposite);

	}

	public List<AbstractTermDto> getSelectedTerms() {

	    List<AbstractTermDto> termDtos = new ArrayList<>();

	    controller.getSelectedSearchResults().forEach(result->termDtos.add(result.getContent()));

	    return termDtos;

	}

}

/**

* Copyright (C) 2020 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.featuretree;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.EOFException;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import java.util.UUID;

import org.eclipse.swt.SWTException;

import org.eclipse.swt.dnd.ByteArrayTransfer;

import org.eclipse.swt.dnd.TransferData;

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

import eu.etaxonomy.cdm.model.description.Feature;

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

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

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * @author k.luther

 * @since Oct 13, 2020

 */

public class TermNodeDtoTransfer extends ByteArrayTransfer {

    private static TermNodeDtoTransfer instance = new TermNodeDtoTransfer();

    private static final String TYPE_NAME = "featureNodeDto-transfer-format";

    private static final int TYPEID = registerType(TYPE_NAME);

    /**

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

     *

     * @return a {@link eu.etaxonomy.taxeditor.featuretree.FeatureNodeTransfer} object.

     */

    public static synchronized TermNodeDtoTransfer getInstance() {

        return instance;

    }

    private TermNodeDtoTransfer() {

    }

    /** {@inheritDoc} */

    @Override

    protected int[] getTypeIds() {

        return new int[] { TYPEID };

    }

    /** {@inheritDoc} */

    @Override

    protected String[] getTypeNames() {

        return new String[] { TYPE_NAME };

    }

    @Override

    protected void javaToNative(Object object, TransferData transferData) {

        if (object != null){

            byte[] bytes = toByteArray((TermNodeDto[]) object);

            if (bytes != null) {

                super.javaToNative(bytes, transferData);

            }

        }

    }

    @Override

    protected Object nativeToJava(TransferData transferData) {

        try{

            byte[] bytes = (byte[]) super.nativeToJava(transferData);

            if (bytes != null){

                return fromByteArray(bytes);

            }

        }catch (SWTException e){

            MessagingUtils.warningDialog("The new imported node needs to be saved first", this, "Newly created nodes can not be moved without saving");

        }

        return null;

    }

    protected byte[] toByteArray(TermNodeDto[] elements) {

        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();

        DataOutputStream out = new DataOutputStream(byteOut);

        byte[] bytes = null;

        try {

            for(TermNodeDto element : elements){

                if (element.getUuid() == null){

                //  MessagingUtils.warningDialog("The new imported node needs to be saved first", this, "Newly created nodes can not be moved without saving");

                }else{

                    writeElementUuid(element, out);

                }

            }

            out.close();

            bytes = byteOut.toByteArray();

        } catch (IOException e) {

            // when in doubt send nothing

        }

        return bytes;

    }

    protected Object[] fromByteArray(byte[] bytes) {

        DataInputStream in = new DataInputStream(

                new ByteArrayInputStream(bytes));

        try {

            List<TermNodeDto> elements = new ArrayList<TermNodeDto>();

            try{

                while(true){

                    UUID uuid = readElementUuid(in);

                    elements.add(loadElement(uuid));

                }

            }catch(EOFException e){

                return  elements.toArray();

            }

        } catch (IOException e) {

            return null;

        }

    }

    public TermNodeDto loadElement(UUID uuid){

        TermNode<Feature> node = CdmStore.getService(ITermNodeService.class).load(uuid);

        return TermNodeDto.fromNode(node, null);

    }

    public UUID readElementUuid(DataInputStream in) throws IOException{

        return UUID.fromString(in.readUTF());

    }

    private void writeElementUuid(TermNodeDto element, DataOutputStream out) throws IOException {

        out.writeUTF(element.getUuid().toString());

    }

}

/**

 * 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.featuretree;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.EOFException;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import java.util.UUID;

import org.eclipse.swt.SWTException;

import org.eclipse.swt.dnd.ByteArrayTransfer;

import org.eclipse.swt.dnd.TransferData;

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

import eu.etaxonomy.cdm.model.description.Feature;

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

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * <p>FeatureNodeTransfer class.</p>

 *

 * @author n.hoffmann

 * @created Aug 5, 2010

 */

public class TermNodeTransfer extends ByteArrayTransfer {

	private static TermNodeTransfer instance = new TermNodeTransfer();

	private static final String TYPE_NAME = "featureNode-transfer-format";

	private static final int TYPEID = registerType(TYPE_NAME);

	/**

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

	 *

	 * @return a {@link eu.etaxonomy.taxeditor.featuretree.FeatureNodeTransfer} object.

	 */

	public static synchronized TermNodeTransfer getInstance() {

		return instance;

	}

	private TermNodeTransfer() {

	}

	/** {@inheritDoc} */

	@Override

	protected int[] getTypeIds() {

		return new int[] { TYPEID };

	}

	/** {@inheritDoc} */

	@Override

	protected String[] getTypeNames() {

		return new String[] { TYPE_NAME };

	}

	@Override

    protected void javaToNative(Object object, TransferData transferData) {

        if (object != null){

            byte[] bytes = toByteArray((TermNode[]) object);

            if (bytes != null) {

                super.javaToNative(bytes, transferData);

            }

        }

    }

    @Override

    protected Object nativeToJava(TransferData transferData) {

        try{

            byte[] bytes = (byte[]) super.nativeToJava(transferData);

            if (bytes != null){

                return fromByteArray(bytes);

            }

        }catch (SWTException e){

            MessagingUtils.warningDialog("The new imported node needs to be saved first", this, "Newly created nodes can not be moved without saving");

        }

        return null;

    }

    protected byte[] toByteArray(TermNode[] elements) {

        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();

        DataOutputStream out = new DataOutputStream(byteOut);

        byte[] bytes = null;

        try {

            for(TermNode element : elements){

                if (element.getUuid() == null){

                //                    MessagingUtils.warningDialog("The new imported node needs to be saved first", this, "Newly created nodes can not be moved without saving");

                }else{

                    writeElementUuid(element, out);

                }

            }

            out.close();

            bytes = byteOut.toByteArray();

        } catch (IOException e) {

            // when in doubt send nothing

        }

        return bytes;

    }

    protected Object[] fromByteArray(byte[] bytes) {

        DataInputStream in = new DataInputStream(

                new ByteArrayInputStream(bytes));

        try {

            List<TermNode> elements = new ArrayList<TermNode>();

            try{

                while(true){

                    UUID uuid = readElementUuid(in);

                    elements.add(loadElement(uuid));

                }

            }catch(EOFException e){

                return  elements.toArray();

            }

        } catch (IOException e) {

            return null;

        }

    }

    public TermNode loadElement(UUID uuid){

        TermNode<Feature> node = CdmStore.getService(IFeatureNodeService.class).load(uuid);

        return node;

    }

    public UUID readElementUuid(DataInputStream in) throws IOException{

        return UUID.fromString(in.readUTF());

    }

    private void writeElementUuid(Object element, DataOutputStream out) throws IOException {

        out.writeUTF(((TermNode)element).getUuid().toString());

    }

}

/**

* 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.featuretree;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import org.eclipse.jface.viewers.ITreeContentProvider;

import org.eclipse.jface.viewers.Viewer;

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

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

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

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

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

/**

 * <p>TermTreeContentProvider class.</p>

 *

 * @author n.hoffmann

 * @created Aug 5, 2010

 */

public class TermTreeContentProvider<T extends DefinedTermBase> implements ITreeContentProvider {

    private Viewer viewer;

    private TermNodeDto oldInput;

    private TermNodeDto newInput;

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

	@Override

	public void dispose() {}

	@Override

	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

	    this.viewer = viewer;

	    if (oldInput instanceof TermNodeDto){

	        this.oldInput = (TermNodeDto)oldInput;

	    }

	    if (newInput instanceof TermNodeDto){

	        this.newInput = (TermNodeDto)newInput;

	    }

	    if (oldInput instanceof TermTreeDto){

	        this.oldInput = ((TermTreeDto)oldInput).getRoot();

	    }

	    if (newInput instanceof TermTreeDto){

            this.newInput = ((TermTreeDto)newInput).getRoot();

        }

	}

	@Override

	public Object[] getElements(Object inputElement) {

		return this.getChildren(inputElement);

	}

	@Override

	public Object[] getChildren(Object parentElement) {

	    if(parentElement instanceof TermTree){

            List<TermNode<?>> children = ((TermTree) parentElement).getRootChildren();

            return children.toArray();

        }else if(parentElement instanceof TermNode){

            List<TermNode<?>> children = ((TermNode) parentElement).getChildNodes();

            return children.toArray();

        }

		if(parentElement instanceof TermTreeDto){

		    if (((TermTreeDto) parentElement).getRoot() != null){

		        List<TermNodeDto> children = ((TermTreeDto) parentElement).getRoot().getChildren();

		        return children.toArray();

		    }

			return new Object[]{};

		}else if(parentElement instanceof TermNodeDto){

			List<TermNodeDto> children = ((TermNodeDto) parentElement).getChildren();

			return children.toArray();

		}else if(parentElement instanceof List){

			return ((List<TermNodeDto>) parentElement).toArray();

		}else{

			return new Object[]{};

		}

	}

	@Override

	public Object getParent(Object element) {

	    if(element instanceof TermNode){

            return ((TermNode<?>) element).getParent();

        }

	    if(element instanceof TermNodeDto){

	        TermNodeDto parent = uuidTermMap.get(((TermNodeDto) element).getParentUuid());

	        return parent;

	    }

		return null;

	}

	public Map<UUID, TermNodeDto> getUuidTermMap() {

        return uuidTermMap;

    }

	public void setUuidTermMap(Map<UUID, TermNodeDto> uuidTermMap) {

        this.uuidTermMap = uuidTermMap;

    }

	@Override

	public boolean hasChildren(Object element) {

		return getChildren(element).length != 0;

	}

}

/**

* 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.featuretree;

import java.util.ArrayList;

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.preference.IPreferenceKeys;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

/**

 * @author n.hoffmann

 * @created Aug 5, 2010

 */

public class TermTreeLabelProvider extends TermDtoLabelProvider {

    public TermTreeLabelProvider() {

        showIdInVoc = PreferencesUtil.getBooleanValue(IPreferenceKeys.SHOW_VOCABULARY_ID_FOR_TERM_LABELS_IN_TREE_EDITOR, true);

    }

	@Override

	public String getText(Object element) {

		if(element instanceof TermTreeDto){

			return ((TermTreeDto) element).getRepresentation_L10n() != null? ((TermTreeDto) element).getRepresentation_L10n() :((TermTreeDto) element).getTitleCache()  ;

		}else if(element instanceof TermNodeDto){

		    TermDto term = ((TermNodeDto) element).getTerm();

		    if(term!=null){

//		        boolean showIdInVoc = PreferencesUtil.getBooleanValue(IPreferenceKeys.SHOW_VOCABULARY_ID_FOR_TERM_LABELS_IN_TREE_EDITOR, true);

		        return super.getText(term);

		    }

		}else if(element instanceof TermNode){

            DefinedTermBase<?> term = ((TermNode<?>) element).getTerm();

            if(term!=null){

                Representation rep = term.getRepresentation(PreferencesUtil.getGlobalLanguage());

                if (rep == null){

                    rep = term.getPreferredRepresentation(new ArrayList<Language>());

                }

                return rep != null? rep.getLabel() : term.getTitleCache();

            }

        }else if(element instanceof TermTree){

            return ((TermTree<?>) element).getTitleCache();

        }

		return "No label provided";

	}

}

/**

 *

 */

package eu.etaxonomy.taxeditor.featuretree;

import org.eclipse.core.expressions.PropertyTester;

import org.eclipse.jface.viewers.IStructuredSelection;

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

/**

 * Property tester used by the feature tree menu.

 *

 * @author pplitzner

 * @since Jan 30, 2019

 *

 */

public class TermTreePropertyTester extends PropertyTester {

	private static final String FEATURE_TREE= "isFeatureTree"; //$NON-NLS-1$

	@Override

    public boolean test(Object receiver, String property, Object[] args,

			Object expectedValue) {

	    Object[] selectedElements = ((IStructuredSelection) receiver).toArray();

	    if(selectedElements.length == 0){

			// nothing selected so all tests should fail

			return false;

		}

		if(FEATURE_TREE.equals(property)){

		    return isTermTree(selectedElements);

		}

		else{

			return false;

		}

	}

	private boolean isTermTree(Object[] selectedElements) {

	    for (Object object : selectedElements){

	        if(!(object instanceof TermTree)){

	            return false;

	        }

	    }

	    return true;

	}

}

/**

* 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.featuretree.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.featuretree.CharacterNodeDtoTransfer;

import eu.etaxonomy.taxeditor.featuretree.TermTreeContentProvider;

import eu.etaxonomy.taxeditor.featuretree.TermTreeLabelProvider;

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.ui.dialog.selection.FeatureTreeSelectionDialog;

/**

 * @author pplitzner

 * @since Jun 19, 2017

 */

public class FeatureTreeDtoEditorComposite <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 FeatureTreeDtoEditorComposite(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);

        }