EDIT

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

    private FeatureTreeEditorComposite<Feature> featureTreeEditorComposite;

        featureTreeEditorComposite = new FeatureTreeEditorComposite<>(this, SWT.NONE);

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

    public FeatureTreeEditorComposite<Feature> getFeatureTreeEditorComposite() {

        return featureTreeEditorComposite;

        return featureTreeEditorComposite.getFeatureTree();

        featureTreeEditorComposite.setSelectedTree(characters);

        composite.getFeatureTreeEditorComposite().init("Character Tree",

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

public class CharacterDragListener extends FeatureNodeDragListener {

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

public class CharacterDropAdapter extends FeatureTreeDtoDropAdapter {

import eu.etaxonomy.taxeditor.featuretree.FeatureTreeContentProvider;

import eu.etaxonomy.taxeditor.featuretree.FeatureTreeLabelProvider;

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

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

        initFeatureTreeComposite(TermType.Character, characterTreeEditorComposite, new FeatureNodeDtoDragListener(characterTreeEditorComposite.getViewer()),

                new FeatureTreeDtoDropAdapter(this, characterTreeEditorComposite.getViewer(), sync),

        viewer.setContentProvider(new FeatureTreeContentProvider());

        viewer.setLabelProvider(new FeatureTreeLabelProvider());

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

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

        return featureTreeEditorComposite;

            FeatureTreeDtoEditorComposite featureTreeEditorComposite,

            FeatureNodeDtoDragListener featureNodeDragListener,

            FeatureTreeDtoDropAdapter featureNodeDropAdapter,

        featureTreeEditorComposite.init(

                new FeatureTreeChooserListener(featureTreeEditorComposite, termType),

        private FeatureTreeDtoEditorComposite<Feature> featureTreeEditorComposite;

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

            this.featureTreeEditorComposite = featureTreeEditorComposite;

            TermTree tree = FeatureTreeSelectionDialog.select(featureTreeEditorComposite.getDisplay().getActiveShell(), null, termType);

                featureTreeEditorComposite.setSelectedTree(tree);

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

public class AddFeatureToCharacterTreeHandler extends AddFeatureHandler {

		viewer.setContentProvider(new FeatureTreeContentProvider());

		viewer.setLabelProvider(new FeatureTreeLabelProvider());

	private class FeatureTreeContentProvider implements IStructuredContentProvider {

	private class FeatureTreeLabelProvider extends LabelProvider {

/**

* 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 AvailableFeaturesWizard extends Wizard {

	private AvailableFeaturesWizardPage page;

	private Set<DefinedTermBase> additionalFeatures;

    private List<TermVocabularyDto> vocabularyDtos;

    private boolean singleSelection = false;

	public AvailableFeaturesWizard(TermType termType){

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

	}

	public AvailableFeaturesWizard(List<TermVocabularyDto> vocabularyDtos){

	    this.vocabularyDtos = vocabularyDtos;

	}

	/** {@inheritDoc} */

	@Override

	public void addPages() {

		page = new AvailableFeaturesWizardPage(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 AvailableFeaturesWizardPage extends WizardPage {

    private CheckBoxTreeComposite treeComposite;

    private List<TermVocabularyDto> vocabularies;

	protected AvailableFeaturesWizardPage(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.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 FeatureNodeDtoTransfer extends ByteArrayTransfer {

    private static FeatureNodeDtoTransfer instance = new FeatureNodeDtoTransfer();

    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 FeatureNodeDtoTransfer getInstance() {

        return instance;

    }

    private FeatureNodeDtoTransfer() {

    }

    /** {@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 FeatureNodeTransfer extends ByteArrayTransfer {

	private static FeatureNodeTransfer instance = new FeatureNodeTransfer();

	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 FeatureNodeTransfer getInstance() {

		return instance;

	}

	private FeatureNodeTransfer() {

	}

	/** {@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>FeatureTreeContentProvider class.</p>

 *

 * @author n.hoffmann

 * @created Aug 5, 2010

 * @version 1.0

 */

public class FeatureTreeContentProvider<T extends DefinedTermBase> implements ITreeContentProvider {

    Viewer viewer;

    TermNodeDto oldInput;

    TermNodeDto newInput;

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

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.IContentProvider#dispose()

	 */

	/** {@inheritDoc} */

	@Override

	public void dispose() {

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)

	 */

	/** {@inheritDoc} */

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

        }

	}

	/** {@inheritDoc} */

	@Override

	public Object[] getElements(Object inputElement) {

		return this.getChildren(inputElement);

	}

	/** {@inheritDoc} */

	@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[]{};

		}

	}

	/** {@inheritDoc} */

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

    }

    /** {@inheritDoc} */

	@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

 * @version 1.0

 */

public class FeatureTreeLabelProvider extends TermDtoLabelProvider{

	/** {@inheritDoc} */

	@Override

	public String getText(Object element, boolean showIdInVoc) {

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

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

		        return super.getText(term, showIdInVoc);

		    }

		}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 FeatureTreePropertyTester 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 isFeatureTree(selectedElements);

		}

		else{

			return false;

		}

	}

	private boolean isFeatureTree(Object[] selectedElements) {

	    for (Object object : selectedElements){

	        if(!(object instanceof TermTree)){

	            return false;

	        }

	    }

	    return true;

	}

}