EDIT

/**

* 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.persistence.dto.CharacterNodeDto;

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 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);

        return CharacterNodeDto.fromTermNode(node);

    }

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

    }

}

import eu.etaxonomy.taxeditor.featuretree.CharacterNodeDtoTransfer;

                CharacterNodeDtoTransfer.getInstance(),

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

public class CharacterNodeDtoDetailElement extends AbstractCdmDetailElement<TermNodeDto> {

	protected void createControls(ICdmFormElement formElement, TermNodeDto entity, int style) {

    public void setEntity(TermNodeDto entity) {

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

public class CharacterNodeDtoDetailSection extends AbstractCdmDetailSection<TermNodeDto> {

    protected AbstractCdmDetailElement<TermNodeDto> createCdmDetailElement(AbstractCdmDetailSection<TermNodeDto> parentElement,