import eu.etaxonomy.cdm.api.service.ICommonService;\r
import eu.etaxonomy.cdm.api.service.IDatabaseService;\r
import eu.etaxonomy.cdm.api.service.IDescriptionService;\r
+import eu.etaxonomy.cdm.api.service.IDescriptiveDataSetService;\r
import eu.etaxonomy.cdm.api.service.IEntityConstraintViolationService;\r
import eu.etaxonomy.cdm.api.service.IEntityValidationService;\r
import eu.etaxonomy.cdm.api.service.IEventBaseService;\r
import eu.etaxonomy.cdm.api.service.IReferenceService;\r
import eu.etaxonomy.cdm.api.service.IRegistrationService;\r
import eu.etaxonomy.cdm.api.service.IRightsService;\r
-import eu.etaxonomy.cdm.api.service.IService;\r
import eu.etaxonomy.cdm.api.service.ITaxonNodeService;\r
import eu.etaxonomy.cdm.api.service.ITaxonService;\r
+import eu.etaxonomy.cdm.api.service.ITermNodeService;\r
import eu.etaxonomy.cdm.api.service.ITermService;\r
+import eu.etaxonomy.cdm.api.service.ITermTreeService;\r
import eu.etaxonomy.cdm.api.service.ITestService;\r
import eu.etaxonomy.cdm.api.service.IUserService;\r
import eu.etaxonomy.cdm.api.service.IVocabularyService;\r
-import eu.etaxonomy.cdm.api.service.IDescriptiveDataSetService;\r
import eu.etaxonomy.cdm.api.service.molecular.IAmplificationService;\r
import eu.etaxonomy.cdm.api.service.molecular.IPrimerService;\r
import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;\r
import eu.etaxonomy.cdm.ext.geo.IEditGeoService;\r
import eu.etaxonomy.cdm.io.service.IIOService;\r
-import eu.etaxonomy.cdm.model.common.CdmBase;\r
import eu.etaxonomy.cdm.persistence.hibernate.permission.CdmPermissionEvaluator;\r
import eu.etaxonomy.cdm.persistence.hibernate.permission.ICdmPermissionEvaluator;\r
import eu.etaxonomy.cdm.persistence.hibernate.permission.UnanimousBasedUnrevokable;\r
public IFeatureTreeService getFeatureTreeService(){\r
return (IFeatureTreeService) getService(IFeatureTreeService.class, "/remoting/featuretree.service", new CdmServiceRequestExecutor());\r
}\r
+ @Override\r
+ public ITermTreeService getTermTreeService() {\r
+ return (ITermTreeService) getService(ITermTreeService.class, "/remoting/termtree.service", new CdmServiceRequestExecutor());\r
+ }\r
\r
@Override\r
public IFeatureNodeService getFeatureNodeService(){\r
return (IFeatureNodeService) getService(IFeatureNodeService.class, "/remoting/featurenode.service", new CdmServiceRequestExecutor());\r
}\r
+ \r
+ @Override\r
+ public ITermNodeService getTermNodeService() {\r
+ return (ITermNodeService) getService(ITermNodeService.class, "/remoting/termnode.service", new CdmServiceRequestExecutor());\r
+ }\r
\r
@Override\r
public IVocabularyService getVocabularyService(){\r
public ITestService getTestService() {\r
return (ITestService) getService(ITestService.class, "/remoting/test.service", new CdmServiceRequestExecutor());\r
}\r
+\r
+\r
}\r
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Tree;
-import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.model.description.Character;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
import eu.etaxonomy.cdm.model.name.Rank;
+import eu.etaxonomy.cdm.model.term.TermTree;
+import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.persistence.dto.TermDto;
import eu.etaxonomy.cdm.remote.l10n.TermRepresentation_L10n;
import eu.etaxonomy.taxeditor.editor.l10n.Messages;
return featureTreeEditorComposite;
}
- public FeatureTree<Character> getCharacters(){
+ public TermTree<Character> getCharacters(){
return featureTreeEditorComposite.getFeatureTree();
}
- public void setCharacters(FeatureTree<Character> characters) {
+ public void setCharacters(TermTree<Character> characters) {
featureTreeEditorComposite.setSelectedTree(characters);
}
import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;
import eu.etaxonomy.cdm.persistence.dto.TermDto;
}
}
}
- FeatureTree<Character> characters = composite.getCharacters();
+ TermTree<Character> characters = composite.getCharacters();
if(characters!=null){
//save characters because they can be modified in this editor
- characters.getDistinctFeatures().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
+ characters.getDistinctTerms().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
}
import org.eclipse.swt.widgets.Display;
import eu.etaxonomy.cdm.model.description.Character;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.featuretree.CharacterTransfer;
import eu.etaxonomy.taxeditor.featuretree.e4.FeatureNodeDragListener;
!structureViewer.getSelection().isEmpty()
&& !propertyViewer.getSelection().isEmpty()
&& ((IStructuredSelection) structureViewer.getSelection()).toList()
- .stream().allMatch(element -> element instanceof FeatureNode)
+ .stream().allMatch(element -> element instanceof TermNode)
&& ((IStructuredSelection) propertyViewer.getSelection()).toList()
- .stream().allMatch(element -> element instanceof FeatureNode);
+ .stream().allMatch(element -> element instanceof TermNode);
if(!event.doit){
return;
}
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
import eu.etaxonomy.cdm.model.description.Character;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.featuretree.CharacterTransfer;
import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeDropAdapter;
import eu.etaxonomy.taxeditor.store.CdmStore;
@Override
protected Object determineTarget(DropTargetEvent event) {
- return event.item == null ? ((FeatureTree)getViewer().getInput()).getRoot() : event.item.getData();
+ return event.item == null ? ((TermTree<Feature>)getViewer().getInput()).getRoot() : event.item.getData();
}
@Override
if(!characterEditor.isVocabularySet()){
return false;
}
- FeatureNode target = (FeatureNode) getCurrentTarget();
+ TermNode<Feature> target = (TermNode<Feature>) getCurrentTarget();
if(data instanceof Object[]){
Object[] transferObjects = (Object[])data;
for(int i=0;i<transferObjects.length;i++){
Character character = (Character)object;
if(target==null){
//drop on feature tree
- target = ((FeatureTree)getViewer().getInput()).getRoot();
+ target = ((TermTree<Feature>)getViewer().getInput()).getRoot();
}
CdmStore.getService(IFeatureNodeService.class).createChildFeatureNode(target.getUuid(), character, characterEditor.getVocabulary().getUuid());
}
import eu.etaxonomy.cdm.api.service.ITermService;
import eu.etaxonomy.cdm.api.service.IVocabularyService;
import eu.etaxonomy.cdm.model.description.Character;
+import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
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.model.term.TermType;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.model.term.VocabularyEnum;
return;
}
Collection<Character> characters = createCharacters((TreeSelection)structureTreeSelection, (TreeSelection)propertyTreeSelection);
- FeatureNode<Character> parent = ((FeatureTree<Character>) characterTreeEditorComposite.getViewer().getInput()).getRoot();
+ TermNode<Character> parent = ((TermTree<Character>) characterTreeEditorComposite.getViewer().getInput()).getRoot();
for (Character character : characters) {
//add new Character to feature tree
CdmStore.getService(IFeatureNodeService.class).createChildFeatureNode(parent.getUuid(), character, vocabulary.getUuid());
public static Collection<Character> createCharacters(TreeSelection structureTreeSelection, TreeSelection propertyTreeSelection){
Set<Character> characters = new HashSet<>();
//get selected structures and properties
- Iterator<FeatureNode<DefinedTermBase>> structureIterator = structureTreeSelection.iterator();
+ Iterator<TermNode<DefinedTermBase>> structureIterator = structureTreeSelection.iterator();
//create all combinations of structures and properties
while(structureIterator.hasNext()){
- FeatureNode<DefinedTermBase> structureNode = structureIterator.next();
- Iterator<FeatureNode<DefinedTermBase>> propertiesIterator = propertyTreeSelection.iterator();
+ TermNode<DefinedTermBase> structureNode = structureIterator.next();
+ Iterator<TermNode<DefinedTermBase>> propertiesIterator = propertyTreeSelection.iterator();
while(propertiesIterator.hasNext()){
- FeatureNode<DefinedTermBase> propertyNode = propertiesIterator.next();
+ TermNode<DefinedTermBase> propertyNode = propertiesIterator.next();
Representation structureRepresentation = structureNode.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());
Representation propertyRepresentation = propertyNode.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());
String label = null;
// commit the conversation and start a new transaction immediately
conversation.commit(true);
- FeatureTree<Character> featureTree = characterTreeEditorComposite.getFeatureTree();
+ TermTree<Character> featureTree = characterTreeEditorComposite.getFeatureTree();
if(featureTree!=null){
//save characters because they can be modified in this editor
- featureTree.getDistinctFeatures().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
+ featureTree.getDistinctTerms().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
}
CdmStore.getService(IFeatureTreeService.class).saveOrUpdate(featureTree);
});
Map<Object, List<String>> propertyPathMap =
new HashMap<Object, List<String>>();
- propertyPathMap.put(FeatureNode.class,propertyPaths);
+ propertyPathMap.put(TermNode.class,propertyPaths);
return propertyPathMap;
}
@Override
- public List<FeatureTree<Character>> getRootEntities() {
- List<FeatureTree<Character>> root = new ArrayList<>();
+ public List<TermTree<Character>> getRootEntities() {
+ List<TermTree<Character>> root = new ArrayList<>();
root.add(characterTreeEditorComposite.getFeatureTree());
return root;
}
return (IStructuredSelection) characterTreeEditorComposite.getViewer().getSelection();
}
- public FeatureTree<Character> getCharacterTree(){
+ public TermTree<Character> getCharacterTree(){
return characterTreeEditorComposite.getFeatureTree();
}
}
private class FeatureTreeChooserListener extends SelectionAdapter{
- private FeatureTreeEditorComposite<?> featureTreeEditorComposite;
+ private FeatureTreeEditorComposite<Feature> featureTreeEditorComposite;
private TermType termType;
- public FeatureTreeChooserListener(FeatureTreeEditorComposite<?> featureTreeEditorComposite, TermType termType) {
+ public FeatureTreeChooserListener(FeatureTreeEditorComposite<Feature> featureTreeEditorComposite, TermType termType) {
super();
this.featureTreeEditorComposite = featureTreeEditorComposite;
this.termType = termType;
@Override
public void widgetSelected(SelectionEvent e) {
- FeatureTree tree = FeatureTreeSelectionDialog.select(featureTreeEditorComposite.getDisplay().getActiveShell(), null, termType);
+ TermTree<Feature> tree = FeatureTreeSelectionDialog.select(featureTreeEditorComposite.getDisplay().getActiveShell(), null, termType);
if(tree!=null){
featureTreeEditorComposite.setSelectedTree(tree);
}
@Override
public boolean postOperation(Object objectAffectedByOperation) {
characterTreeEditorComposite.getViewer().refresh();
- if(objectAffectedByOperation instanceof FeatureNode){
+ if(objectAffectedByOperation instanceof TermNode){
StructuredSelection selection = new StructuredSelection(objectAffectedByOperation);
characterTreeEditorComposite.getViewer().setSelection(selection);
}
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.MeasurementUnit;
import eu.etaxonomy.cdm.model.description.State;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.persistence.dto.SpecimenNodeWrapper;
import eu.etaxonomy.cdm.persistence.dto.TermDto;
getNatTableState().remove(PersistenceDialog.ACTIVE_VIEW_CONFIGURATION_KEY);
}
- private List<Character> initCharacterList(FeatureNode<Character> node){
+ private List<Character> initCharacterList(TermNode<Character> node){
List<Character> characters = new ArrayList<>();
node.getChildNodes().forEach(childNode->
{
public void initDescriptiveDataSet(DescriptiveDataSet descriptiveDataSet){
this.descriptiveDataSet = descriptiveDataSet;
//get features/columns stored in descriptive data set
- FeatureTree<Character> tree = descriptiveDataSet.getDescriptiveSystem();
+ TermTree<Character> tree = descriptiveDataSet.getDescriptiveSystem();
characters = initCharacterList(tree.getRoot());
//init state data for categorical features
import eu.etaxonomy.cdm.model.common.Marker;
import eu.etaxonomy.cdm.model.description.DescriptionBase;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
+import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.IDescribable;
import eu.etaxonomy.cdm.model.description.IndividualsAssociation;
import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput;
import eu.etaxonomy.taxeditor.model.FeatureNodeContainer;
import eu.etaxonomy.taxeditor.model.FeatureNodeContainerTree;
* @param description
* @return
*/
- private FeatureTree getFeatureTree(DescriptionBase description){
+ private TermTree<Feature> getFeatureTree(DescriptionBase description){
- FeatureTree<?> featureTree = null;
+ TermTree<Feature> featureTree = null;
// TODO change this to the feature tree associated with this taxon
// description
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.VocabularyEnum;
import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput;
import eu.etaxonomy.taxeditor.editor.l10n.Messages;
Object selectedElement = selection.getFirstElement();
if (selectedElement instanceof DescriptionBase<?>) {
- FeatureTree<?> featureTree = getFeatureTree((DescriptionBase<?>) selectedElement);
+ TermTree<?> featureTree = getFeatureTree((DescriptionBase<?>) selectedElement);
- for (FeatureNode<?> childNode : featureTree.getRootChildren()) {
+ for (TermNode<?> childNode : featureTree.getRootChildren()) {
createMenuItem(menu, childNode.getTerm(), globalLanguage);
}
} else if (selectedElement instanceof FeatureNodeContainer) {
- FeatureNode<?> featureNode = ((FeatureNodeContainer) selectedElement)
+ TermNode<?> featureNode = ((FeatureNodeContainer) selectedElement)
.getFeatureNode();
// add the feature to the menu
createMenuItem(menu, featureNode.getTerm(), globalLanguage);
// add possible children to the menu
- for (FeatureNode<?> childNode : featureNode.getChildNodes()) {
+ for (TermNode<?> childNode : featureNode.getChildNodes()) {
createMenuItem(menu, childNode.getTerm(), globalLanguage);
}
} else if (selectedElement instanceof DescriptionElementBase) {
* @param description
* @return
*/
- private FeatureTree<?> getFeatureTree(DescriptionBase description) {
- FeatureTree<?> featureTree = null;
+ private TermTree<?> getFeatureTree(DescriptionBase description) {
+ TermTree<?> featureTree = null;
// TODO change this to the feature tree associated with this taxon
// description
if (featureTree == null) {
featureTree = TermEditorInput.getDefaultFeatureTree();
- }
+ }
if (description instanceof TaxonNameDescription){
List<Feature> terms = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()));
terms.remove(Feature.PROTOLOGUE());
- featureTree = FeatureTree.NewInstance(terms);
+ featureTree = TermTree.NewInstance(terms);
}
return featureTree;
/**
* @author k.luther
* @date 06.12.2016
- *
*/
public class DatabaseRepairUpdateSortIndicesWizard extends Wizard implements IPostMoniteredOperationEnabled{
// private final DatabaseRepairSortIndexPage repairSortIndexPage;
if (config == null){
ICdmSource source= CdmStore.getActiveCdmSource();
config = SortIndexUpdaterConfigurator.NewInstance();
- config.setDoFeatureNode(false);
+ config.setDoTermNode(false);
config.setDoPolytomousKeyNode(false);
-
-
}
- if (config.isDoFeatureNode() || config.isDoPolytomousKeyNode() || config.isDoTaxonNode()){
+ if (config.isDoTermNode() || config.isDoPolytomousKeyNode() || config.isDoTaxonNode()){
final UUID uuid = longRunningTaskService.monitLongRunningTask(config);
Display.getDefault().asyncExec(new Runnable() {
DatabaseRepairUpdateSortIndicesWizard.this,
null,
true);
-
}
-
});
-
-
}
-
return true;
}
@Override
public void postOperation(IRemotingProgressMonitor monitor) {
// TODO Auto-generated method stub
-
}
-
-
}
});
Button checkBoxFeatureNode = new Button(composite, SWT.CHECK);
- checkBoxFeatureNode.setSelection(sortIndexConfig.isDoFeatureNode());
+ checkBoxFeatureNode.setSelection(sortIndexConfig.isDoTermNode());
checkBoxFeatureNode.setText(Messages.DatabaseRepairPage_featureNodes);
checkBoxFeatureNode
.setToolTipText(Messages.DatabaseRepairPage_toolTipFeatureNodes);
checkBoxFeatureNode.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
- sortIndexConfig.setDoFeatureNode(!sortIndexConfig.isDoFeatureNode());
+ sortIndexConfig.setDoTermNode(!sortIndexConfig.isDoTermNode());
}
});
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
/**
*
* @author pplitzner
* @since May 24, 2019
- *
*/
public class FeatureTreeViewerComparator extends ViewerComparator {
@Override
public int compare(Viewer viewer, Object e1, Object e2) {
- if(e1 instanceof FeatureTree && e2 instanceof FeatureTree) {
- return ((FeatureTree)e1).getTitleCache().toLowerCase().compareTo(((FeatureTree) e2).getTitleCache().toLowerCase());
+ if(e1 instanceof TermTree && e2 instanceof TermTree) {
+ return ((TermTree<?>)e1).getTitleCache().toLowerCase().compareTo(((TermTree<?>) e2).getTitleCache().toLowerCase());
}
return super.compare(viewer, e1, e2);
}
import eu.etaxonomy.cdm.api.service.IVocabularyService;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.term.DefinedTerm;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.model.term.VocabularyEnum;
// FIXME: the default feature should be move to CdmApplicationState
// where it is a singleton instance variable
- private static FeatureTree defaultFeatureTree = null;
- private static FeatureTree defaultNameFeatureTree = null;
+ private static TermTree<Feature> defaultFeatureTree = null;
+ private static TermTree<Feature> defaultNameFeatureTree = null;
private List<String> termClasses = Arrays.asList(new String[]{
DefinedTerm.class.getName()
updateDefaultFeatureTree();
}
- public static FeatureTree getDefaultFeatureTree() {
+ public static TermTree<Feature> getDefaultFeatureTree() {
if(defaultFeatureTree == null) {
List<Feature> features = TermStore.getTerms(Feature.class);
List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null);
features.remove(feature);
}
}
- defaultFeatureTree = FeatureTree.NewInstance(features);
+ defaultFeatureTree = TermTree.NewInstance(features);
}
return defaultFeatureTree;
}
- public static FeatureTree getDefaultNameFeatureTree() {
+ public static TermTree<Feature> getDefaultNameFeatureTree() {
if(defaultNameFeatureTree == null) {
List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null);
- defaultNameFeatureTree = FeatureTree.NewInstance(nameFeatures);
+ defaultNameFeatureTree = TermTree.NewInstance(nameFeatures);
}
return defaultNameFeatureTree;
}
import org.eclipse.swt.dnd.TransferData;
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
-import eu.etaxonomy.cdm.model.term.Representation;
import eu.etaxonomy.cdm.model.description.Character;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+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;
String string = in.readUTF();
String[] split = string.split(",");
IFeatureNodeService featureNodeService = CdmStore.getService(IFeatureNodeService.class);
- FeatureNode structure = featureNodeService.load(UUID.fromString(split[0]));
- FeatureNode property = featureNodeService.load(UUID.fromString(split[1]));
+ TermNode<DefinedTerm> structure = featureNodeService.load(UUID.fromString(split[0]));
+ TermNode<DefinedTerm> property = featureNodeService.load(UUID.fromString(split[1]));
Representation structureRepresentation = structure.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());
Representation propertyRepresentation = property.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());
String label = null;
import java.util.UUID;
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.model.CdmObjectTransfer;
import eu.etaxonomy.taxeditor.store.CdmStore;
*
* @author n.hoffmann
* @created Aug 5, 2010
- * @version 1.0
*/
-public class FeatureNodeTransfer extends CdmObjectTransfer<FeatureNode> {
+public class FeatureNodeTransfer extends CdmObjectTransfer<TermNode<Feature>> {
private static FeatureNodeTransfer instance = new FeatureNodeTransfer();
private static final String TYPE_NAME = "featureNode-transfer-format";
return new String[] { TYPE_NAME };
}
- /* (non-Javadoc)
- * @see eu.etaxonomy.taxeditor.model.CdmObjectTransfer#loadElement(java.util.UUID)
- */
@Override
- public FeatureNode loadElement(UUID uuid) {
+ public TermNode<Feature> loadElement(UUID uuid) {
return CdmStore.getService(IFeatureNodeService.class).load(uuid);
}
}
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermTree;
/**
* <p>FeatureTreeContentProvider class.</p>
}
- /* (non-Javadoc)
- * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
- */
/** {@inheritDoc} */
@Override
public Object[] getElements(Object inputElement) {
/** {@inheritDoc} */
@Override
public Object[] getChildren(Object parentElement) {
- if(parentElement instanceof FeatureTree){
- List<FeatureNode> children = ((FeatureTree) parentElement).getRootChildren();
+ if(parentElement instanceof TermTree){
+ List<TermNode<Feature>> children = ((TermTree<Feature>) parentElement).getRootChildren();
return children.toArray();
- }else if(parentElement instanceof FeatureNode){
- List<FeatureNode> children = ((FeatureNode) parentElement).getChildNodes();
+ }else if(parentElement instanceof TermNode){
+ List<TermNode<Feature>> children = ((TermNode<Feature>) parentElement).getChildNodes();
return children.toArray();
}else if(parentElement instanceof List){
- return ((List) parentElement).toArray();
+ return ((List<TermNode<Feature>>) parentElement).toArray();
}else{
return new Object[]{};
}
/** {@inheritDoc} */
@Override
public Object getParent(Object element) {
- if(element instanceof FeatureNode){
- return ((FeatureNode) element).getParent();
+ if(element instanceof TermNode){
+ return ((TermNode<Feature>) element).getParent();
}
return null;
}
import org.eclipse.jface.viewers.LabelProvider;
-import eu.etaxonomy.cdm.model.term.DefinedTermBase;
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.FeatureNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
/**
/** {@inheritDoc} */
@Override
public String getText(Object element) {
- if(element instanceof FeatureTree){
- return ((FeatureTree) element).getTitleCache();
- }else if(element instanceof FeatureNode){
- DefinedTermBase term = ((FeatureNode) element).getTerm();
+ if(element instanceof TermTree){
+ return ((TermTree) element).getTitleCache();
+ }else if(element instanceof TermNode){
+ DefinedTermBase term = ((TermNode) element).getTerm();
if(term!=null){
Representation rep = term.getRepresentation(PreferencesUtil.getGlobalLanguage());
if (rep == null){
import org.eclipse.core.expressions.PropertyTester;
import org.eclipse.jface.viewers.IStructuredSelection;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
/**
* Property tester used by the feature tree menu.
private boolean isFeatureTree(Object[] selectedElements) {
for (Object object : selectedElements){
- if(!(object instanceof FeatureTree)){
+ if(!(object instanceof TermTree)){
return false;
}
}
import org.eclipse.swt.dnd.DragSourceAdapter;
import org.eclipse.swt.dnd.DragSourceEvent;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.featuretree.FeatureNodeTransfer;
public class FeatureNodeDragListener extends DragSourceAdapter {
public void dragSetData(DragSourceEvent event) {
IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
if(selection!=null && !selection.isEmpty()){
- FeatureNode[] featureNodes = (FeatureNode[]) selection.toList().toArray(new FeatureNode[selection.size()]);
+ TermNode<Feature>[] featureNodes = (TermNode<Feature>[]) selection.toList().toArray(new TermNode[selection.size()]);
if (FeatureNodeTransfer.getInstance().isSupportedType(event.dataType)) {
event.data = featureNodes;
}
public void dragStart(DragSourceEvent event) {
event.doit = !viewer.getSelection().isEmpty()
&& ((IStructuredSelection) viewer.getSelection()).toList()
- .stream().allMatch(element -> element instanceof FeatureNode);
+ .stream().allMatch(element -> element instanceof TermNode);
}
}
\ No newline at end of file
import org.eclipse.swt.dnd.TransferData;
import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
import eu.etaxonomy.cdm.model.term.IHasTermType;
import eu.etaxonomy.cdm.model.term.OrderedTermVocabulary;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.persistence.dto.TermDto;
return false;
}
Object currentTarget = getCurrentTarget();
- FeatureNode target = null;
- if(currentTarget instanceof FeatureTree){
- target = ((FeatureTree) currentTarget).getRoot();
+ TermNode<Feature> target = null;
+ if(currentTarget instanceof TermTree){
+ target = ((TermTree) currentTarget).getRoot();
}
- else if(currentTarget instanceof FeatureNode){
- target = (FeatureNode) currentTarget;
+ else if(currentTarget instanceof TermNode){
+ target = (TermNode) currentTarget;
}
int position = 0;
if (target != null) {
int location = getCurrentLocation();
- FeatureNode parent = target.getParent();
+ TermNode<Feature> parent = target.getParent();
if(parent!=null){
if (location == LOCATION_BEFORE) {
position = Math.max(0, parent.getIndex(target));
continue;
}
}
- if(droppedObject instanceof FeatureNode){
- FeatureNode droppedNode = (FeatureNode) droppedObject;
+ if(droppedObject instanceof TermNode){
+ TermNode<Feature> droppedNode = (TermNode<Feature>) droppedObject;
int currentPosition = target.getIndex(droppedNode);
if(currentPosition<position){
position -= 1;
isSupported |= TermTransfer.getInstance().isSupportedType(transferData);
isSupported |= LocalSelectionTransfer.getTransfer().isSupportedType(transferData);
isSupported &= getViewer().getInput()!=null;
- if(target instanceof FeatureTree && getCurrentLocation()!=ViewerDropAdapter.LOCATION_ON){
+ if(target instanceof TermTree && getCurrentLocation()!=ViewerDropAdapter.LOCATION_ON){
isSupported = false;
}
return isSupported;
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
import eu.etaxonomy.cdm.api.service.ITermService;
import eu.etaxonomy.cdm.model.description.Character;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
import eu.etaxonomy.taxeditor.editor.definedterm.FeatureTreeViewerComparator;
}
});
- List<FeatureTree> trees = CdmStore.getService(IFeatureTreeService.class).list(FeatureTree.class, null, null, null, null);
+ List<TermTree> trees = CdmStore.getService(IFeatureTreeService.class).list(TermTree.class, null, null, null, null);
viewer.setComparator(new FeatureTreeViewerComparator());
viewer.setInput(trees);
ISelection clipBoardSelection = LocalSelectionTransfer.getTransfer().getSelection();
Object firstElement = selection.getFirstElement();
- FeatureNode parentNode = null;
- if(firstElement instanceof FeatureNode){
- parentNode = (FeatureNode) firstElement;
+ TermNode<Feature> parentNode = null;
+ if(firstElement instanceof TermNode){
+ parentNode = (TermNode<Feature>) firstElement;
}
- else if(firstElement instanceof FeatureTree){
- parentNode = ((FeatureTree)firstElement).getRoot();
+ else if(firstElement instanceof TermTree){
+ parentNode = ((TermTree<Feature>)firstElement).getRoot();
}
if(parentNode!=null){
- FeatureNode copiedNode = (FeatureNode) ((IStructuredSelection)clipBoardSelection).getFirstElement();
+ TermNode<Feature> copiedNode = (TermNode<Feature>) ((IStructuredSelection)clipBoardSelection).getFirstElement();
AddFeatureOperation operation = new AddFeatureOperation(copiedNode.getTerm().getUuid(), parentNode, this, this);
AbstractUtility.executeOperation(operation, sync);
// commit the conversation and start a new transaction immediately
conversation.commit(true);
- CdmStore.getService(IFeatureTreeService.class).saveOrUpdate(getRootEntities());
+ CdmStore.getService(IFeatureTreeService.class).saveOrUpdate((List)getRootEntities());
- List<FeatureTree> rootEntities = getRootEntities();
- for (FeatureTree featureTree : rootEntities) {
+ List<TermTree<Feature>> rootEntities = getRootEntities();
+ for (TermTree featureTree : rootEntities) {
if(featureTree.getTermType().equals(TermType.Character)){
- FeatureTree<Character> characterTree = featureTree;
+ TermTree<Character> characterTree = featureTree;
//save characters because they can be modified in this editor
- characterTree.getDistinctFeatures().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
+ characterTree.getDistinctTerms().forEach(character->CdmStore.getService(ITermService.class).merge(character,true));
}
}
private void initializeTrees() {
Object[] expandedElements = viewer.getExpandedElements();
viewer.getTree().removeAll();
- List<FeatureTree> trees = CdmStore.getService(IFeatureTreeService.class).list(FeatureTree.class, null, null, null, null);
+ List<TermTree> trees = CdmStore.getService(IFeatureTreeService.class).list(TermTree.class, null, null, null, null);
viewer.setInput(trees);
viewer.setExpandedElements(expandedElements);
}
});
Map<Object, List<String>> propertyPathMap =
new HashMap<Object, List<String>>();
- propertyPathMap.put(FeatureNode.class,propertyPaths);
+ propertyPathMap.put(TermNode.class,propertyPaths);
return propertyPathMap;
}
@Override
- public List<FeatureTree> getRootEntities() {
- return (List<FeatureTree>) viewer.getInput();
+ public List<TermTree<Feature>> getRootEntities() {
+ return (List<TermTree<Feature>>) viewer.getInput();
}
@Override
public boolean postOperation(Object objectAffectedByOperation) {
initializeTrees();
viewer.refresh();
- if(objectAffectedByOperation instanceof FeatureNode){
- FeatureNode node = (FeatureNode)objectAffectedByOperation;
- viewer.expandToLevel(node.getFeatureTree(), 1);
+ if(objectAffectedByOperation instanceof TermNode){
+ TermNode<Feature> node = (TermNode)objectAffectedByOperation;
+ viewer.expandToLevel(node.getGraph(), 1);
}
if(objectAffectedByOperation!=null){
StructuredSelection selection = new StructuredSelection(objectAffectedByOperation);
import org.eclipse.swt.widgets.Tree;
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.model.term.FeatureTree;
import eu.etaxonomy.taxeditor.editor.definedterm.TermTransfer;
import eu.etaxonomy.taxeditor.featuretree.FeatureNodeTransfer;
import eu.etaxonomy.taxeditor.featuretree.FeatureTreeContentProvider;
/**
* @author pplitzner
* @since Jun 19, 2017
- *
*/
public class FeatureTreeEditorComposite <T extends DefinedTermBase> extends Composite{
- private FeatureTree<T> featureTree;
+ private TermTree<T> featureTree;
private Label label_title;
private Text text_title;
btnOpenFeatureTree.addSelectionListener(new SelectionAdapter(){
@Override
public void widgetSelected(SelectionEvent e) {
- FeatureTree<T> tree = FeatureTreeSelectionDialog.select(getDisplay().getActiveShell(),
+ TermTree<T> tree = FeatureTreeSelectionDialog.select(getDisplay().getActiveShell(),
null, termType);
if(tree!=null){
setSelectedTree(tree);
}
}
- public void setSelectedTree(FeatureTree<T> featureTree) {
+ public void setSelectedTree(TermTree<T> featureTree) {
this.featureTree = featureTree;
viewer.setInput(featureTree);
}
}
- public FeatureTree<T> getFeatureTree() {
+ public TermTree<T> getFeatureTree() {
return featureTree;
}
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.swt.widgets.Shell;
+import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.featuretree.AvailableFeaturesWizard;
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
import eu.etaxonomy.taxeditor.featuretree.e4.operation.AddFeatureOperation;
/**
* @author pplitzner
- * @since Jul 12, 2017
- *
+ * @since Jul 12, 2017
*/
public class AddChildFeatureHandler {
if (StoreUtil.promptCheckIsDirty(editor)) {
return;
}
- FeatureNode parent = (FeatureNode)selection.getFirstElement();
+ TermNode<Feature> parent = (TermNode<Feature>)selection.getFirstElement();
// TermChooseWizard wizard = new TermChooseWizard(parent.getTermType());
// WizardDialog dialog = new WizardDialog(shell, wizard);
canExecute = thisPart.getObject() instanceof IFeatureTreeEditor
&& selection!=null
&& selection.size()==1
- && selection.getFirstElement() instanceof FeatureNode;
+ && selection.getFirstElement() instanceof TermNode;
menuItem.setVisible(canExecute);
return canExecute;
}
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.swt.widgets.Shell;
+import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.featuretree.AvailableFeaturesWizard;
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
import eu.etaxonomy.taxeditor.featuretree.e4.operation.AddFeatureOperation;
if (StoreUtil.promptCheckIsDirty(editor)) {
return;
}
- FeatureTree tree = (FeatureTree) selection.getFirstElement();
+ TermTree<Feature> tree = (TermTree<Feature>) selection.getFirstElement();
//
// TermChooseWizard wizard = new TermChooseWizard(tree.getTermType());
// WizardDialog dialog = new WizardDialog(shell, wizard);
canExecute = thisPart.getObject() instanceof IFeatureTreeEditor
&& selection!=null
&& selection.size()==1
- && selection.getFirstElement() instanceof FeatureTree;
+ && selection.getFirstElement() instanceof TermTree;
menuItem.setVisible(canExecute);
return canExecute;
}
import org.eclipse.e4.ui.services.IServiceConstants;
import org.eclipse.jface.viewers.IStructuredSelection;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeEditor;
public class CopyFeatureHandler {
canExecute =part.getObject() instanceof FeatureTreeEditor
&& selection!=null
&& selection.size()==1
- && selection.getFirstElement() instanceof FeatureNode;
+ && selection.getFirstElement() instanceof TermNode;
menuItem.setVisible(canExecute);
return canExecute;
}
import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
import org.eclipse.e4.ui.services.IServiceConstants;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
import eu.etaxonomy.taxeditor.featuretree.e4.operation.CreateFeatureTreeOperation;
return;
}
- FeatureTree tree = FeatureTree.NewInstance(getTermType());
+ TermTree<Feature> tree = TermTree.NewInstance(getTermType());
tree.setTitleCache("New feature tree", true);
CreateFeatureTreeOperation operation = new CreateFeatureTreeOperation(tree, editor, editor);
AbstractUtility.executeOperation(operation, sync);
import org.eclipse.ui.progress.IProgressConstants;
import eu.etaxonomy.cdm.io.descriptive.owl.out.StructureTreeOwlExportConfigurator;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
import eu.etaxonomy.taxeditor.preference.IPreferenceKeys;
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
}
List<UUID> featureTreeUuids = new ArrayList<>();
- selection.toList().stream().filter(o->o instanceof FeatureTree).forEach(tree->featureTreeUuids.add(((FeatureTree)tree).getUuid()));
+ selection.toList().stream().filter(o->o instanceof TermTree).forEach(tree->featureTreeUuids.add(((TermTree)tree).getUuid()));
FileDialog dialog = new FileDialog(shell);
String[] filterNames = {
canExecute = PreferencesUtil.getBooleanValue(IPreferenceKeys.SHOW_EXPERIMENTAL_FEATURES)
&& selection!=null
&& selection.size()==1
- && selection.getFirstElement() instanceof FeatureTree;
+ && selection.getFirstElement() instanceof TermTree;
menuItem.setVisible(canExecute);
return canExecute;
}
import org.eclipse.ui.progress.IProgressConstants;
import eu.etaxonomy.cdm.io.descriptive.word.out.WordExportConfigurator;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
import eu.etaxonomy.taxeditor.preference.IPreferenceKeys;
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
return;
}
- FeatureTree selectedFeatureTree = (FeatureTree) selection.getFirstElement();
+ TermTree<Feature> selectedFeatureTree = (TermTree<Feature>) selection.getFirstElement();
DirectoryDialog dialog = new DirectoryDialog(shell);
String directoryString = dialog.open();
if(directoryString!=null){
canExecute = PreferencesUtil.getBooleanValue(IPreferenceKeys.SHOW_EXPERIMENTAL_FEATURES)
&& selection!=null
&& selection.size()==1
- && selection.getFirstElement() instanceof FeatureTree;
+ && selection.getFirstElement() instanceof TermTree;
menuItem.setVisible(canExecute);
return canExecute;
}
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.featuretree.e4.FeatureTreeEditor;
public class PasteFeatureHandler {
&& selection.size()==1
&& transferSelection instanceof IStructuredSelection
&& ((IStructuredSelection)transferSelection).size()==1
- && ((IStructuredSelection)transferSelection).getFirstElement() instanceof FeatureNode;
+ && ((IStructuredSelection)transferSelection).getFirstElement() instanceof TermNode;
menuItem.setVisible(canExecute);
return canExecute;
}
import org.eclipse.e4.ui.services.IServiceConstants;
import org.eclipse.jface.viewers.IStructuredSelection;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
import eu.etaxonomy.taxeditor.featuretree.e4.operation.RemoveFeatureOperation;
import eu.etaxonomy.taxeditor.model.AbstractUtility;
}
for (Object selectedObject : selection.toArray()) {
- FeatureNode featureNode = (FeatureNode) selectedObject;
+ TermNode<Feature> featureNode = (TermNode<Feature>) selectedObject;
RemoveFeatureOperation operation = new RemoveFeatureOperation(featureNode, editor, editor);
AbstractUtility.executeOperation(operation, sync);
}
boolean canExecute = selection!=null && !selection.isEmpty();
if(selection!=null){
for(Object object:selection.toArray()){
- canExecute &= object instanceof FeatureNode;
+ canExecute &= object instanceof TermNode;
}
}
canExecute &= thisPart.getObject() instanceof IFeatureTreeEditor;
import org.eclipse.e4.ui.services.IServiceConstants;
import org.eclipse.jface.viewers.IStructuredSelection;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.featuretree.e4.IFeatureTreeEditor;
import eu.etaxonomy.taxeditor.featuretree.e4.operation.RemoveFeatureTreeOperation;
import eu.etaxonomy.taxeditor.model.AbstractUtility;
}
for (Object selectedObject : selection.toArray()) {
- FeatureTree featureTree = (FeatureTree) selectedObject;
+ TermTree<Feature> featureTree = (TermTree<Feature>) selectedObject;
RemoveFeatureTreeOperation operation = new RemoveFeatureTreeOperation(featureTree, editor, editor);
AbstractUtility.executeOperation(operation, sync);
}
boolean canExecute = selection!=null && !selection.isEmpty();
if(canExecute){
for(Object object:selection.toArray()){
- canExecute &= object instanceof FeatureTree;
+ canExecute &= object instanceof TermTree;
}
}
canExecute &= thisPart.getObject() instanceof IFeatureTreeEditor;
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
import eu.etaxonomy.cdm.api.service.UpdateResult;
import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
*/
public class AddFeatureOperation extends AbstractPostOperation<Feature> {
- private FeatureNode node;
+ private TermNode<Feature> node;
private int position;
private UUID featureUuid;
- public AddFeatureOperation(UUID featureUuid, FeatureNode node,
+ public AddFeatureOperation(UUID featureUuid, TermNode<Feature> node,
IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
this(featureUuid, node, 0, postOperationEnabled, cdmEntitySessionEnabled);
}
- public AddFeatureOperation(UUID featureUuid, FeatureNode node, int position,
+ public AddFeatureOperation(UUID featureUuid, TermNode<Feature> node, int position,
IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
super("Add Feature", StoreUtil.getUndoContext(), null, postOperationEnabled, cdmEntitySessionEnabled);
this.node = node;
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
import eu.etaxonomy.cdm.api.service.UpdateResult;
import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
* @since Apr 30, 2018
*
*/
-public class AddOntologyTermOperation extends AbstractPostOperation<FeatureNode> {
+public class AddOntologyTermOperation extends AbstractPostOperation<TermNode<Feature>> {
- private FeatureNode target;
+ private TermNode<Feature> target;
private OntologyTermWrapper wrapper;
private TermVocabulary vocabulary;
- public AddOntologyTermOperation(OntologyTermWrapper wrapper, FeatureNode target, TermVocabulary vocabulary,
+ public AddOntologyTermOperation(OntologyTermWrapper wrapper, TermNode<Feature> target, TermVocabulary vocabulary,
IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
super("Add ontology term", StoreUtil.getUndoContext(), target, postOperationEnabled, cdmEntitySessionEnabled);
this.wrapper = wrapper;
import org.eclipse.core.runtime.IStatus;
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
* @since Apr 30, 2018
*
*/
-public class CreateFeatureTreeOperation extends AbstractPostOperation<FeatureTree>{
+public class CreateFeatureTreeOperation extends AbstractPostOperation<TermTree<Feature>>{
- public CreateFeatureTreeOperation(FeatureTree element,
+ public CreateFeatureTreeOperation(TermTree<Feature> element,
IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
super("Create Feature Tree", StoreUtil.getUndoContext(), element, postOperationEnabled, cdmEntitySessionEnabled);
}
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
import eu.etaxonomy.cdm.api.service.UpdateResult;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
* @date 21.01.2019
*
*/
-public class MoveFeatureOperation extends AbstractPostOperation<FeatureNode> {
+public class MoveFeatureOperation extends AbstractPostOperation<TermNode<Feature>> {
- private FeatureNode droppedNode;
- private FeatureNode target;
+ private TermNode<Feature> droppedNode;
+ private TermNode<Feature> target;
private int currentOperation;
private int position;
- public MoveFeatureOperation(FeatureNode droppedNode, FeatureNode target, int position,
+ public MoveFeatureOperation(TermNode<Feature> droppedNode, TermNode<Feature> target, int position,
int currentOperation,
IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
super(currentOperation == DND.DROP_MOVE ? "Move Feature" : "Copy Feature", StoreUtil.getUndoContext(),
import eu.etaxonomy.cdm.api.service.DeleteResult;
import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
-import eu.etaxonomy.cdm.api.service.config.FeatureNodeDeletionConfigurator;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.api.service.config.TermNodeDeletionConfigurator;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
* @since Apr 30, 2018
*
*/
-public class RemoveFeatureOperation extends AbstractPostOperation<FeatureNode>{
+public class RemoveFeatureOperation extends AbstractPostOperation<TermNode<Feature>>{
- public RemoveFeatureOperation(FeatureNode element,
+ public RemoveFeatureOperation(TermNode<Feature> element,
IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
super("Remove Feature", StoreUtil.getUndoContext(), element, postOperationEnabled, cdmEntitySessionEnabled);
}
@Override
public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
- DeleteResult result = CdmStore.getService(IFeatureNodeService.class).deleteFeatureNode(element.getUuid(), new FeatureNodeDeletionConfigurator());
+ DeleteResult result = CdmStore.getService(IFeatureNodeService.class).deleteFeatureNode(element.getUuid(), new TermNodeDeletionConfigurator());
return postExecute(null);
}
import org.eclipse.core.runtime.IStatus;
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
* @since Apr 30, 2018
*
*/
-public class RemoveFeatureTreeOperation extends AbstractPostOperation<FeatureTree>{
+public class RemoveFeatureTreeOperation extends AbstractPostOperation<TermTree<Feature>>{
- public RemoveFeatureTreeOperation(FeatureTree element,
+ public RemoveFeatureTreeOperation(TermTree<Feature> element,
IPostOperationEnabled postOperationEnabled, ICdmEntitySessionEnabled cdmEntitySessionEnabled) {
super("Remove Feature Tree", StoreUtil.getUndoContext(), element, postOperationEnabled, cdmEntitySessionEnabled);
}
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
import eu.etaxonomy.cdm.api.service.IVocabularyService;
import eu.etaxonomy.cdm.common.CdmUtils;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
import eu.etaxonomy.taxeditor.store.CdmStore;
/**
* @author pplitzner
* @since May 23, 2019
- *
*/
public class OwlTermExportWizardPage extends WizardPage {
composite.getSelectVocabularyComposite().getViewer().setInput(areaVocabularies);
composite.getSelectVocabularyComposite().getViewer().addCheckStateListener(e->updateButtons());
- List<FeatureTree> trees = CdmStore.getService(IFeatureTreeService.class).list(FeatureTree.class, null, null, null, null);
+ List<TermTree<Feature>> trees = (List)CdmStore.getService(IFeatureTreeService.class).list(TermTree.class, null, null, null, null);
composite.getSelectFeatureTreeComposite().getViewer().setInput(trees);
composite.getSelectFeatureTreeComposite().getViewer().addCheckStateListener(e->updateButtons());
List<UUID> selectedTrees = new ArrayList<>();
Object[] checkedElements = composite.getSelectFeatureTreeComposite().getViewer().getCheckedElements();
for (Object object : checkedElements) {
- if(object instanceof FeatureTree) {
- selectedTrees.add(((FeatureTree) object).getUuid());
+ if(object instanceof TermTree) {
+ selectedTrees.add(((TermTree) object).getUuid());
}
}
return selectedTrees;
import eu.etaxonomy.cdm.model.description.DescriptionBase;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
+import eu.etaxonomy.cdm.model.term.TermNode;
/**
* This class is a simple container to allow generation of a datastructure that
- private FeatureNode<Feature> featureNode;
+ private TermNode<Feature> featureNode;
private List<FeatureNodeContainer> children = new ArrayList<FeatureNodeContainer>();
private List<DescriptionElementBase> descriptionElements = new ArrayList<DescriptionElementBase>();
* @param description
* @return
*/
- protected void findLeaves(FeatureNode<Feature> featureNode) {
+ protected void findLeaves(TermNode<Feature> featureNode) {
if(featureNode.isLeaf()){
buildLeaf(featureNode);
}else{
- for(FeatureNode<Feature> childNode : featureNode.getChildNodes()){
+ for(TermNode<Feature> childNode : featureNode.getChildNodes()){
findLeaves(childNode);
}
}
* @param description
* @return
*/
- private void buildLeaf(FeatureNode<Feature> featureNode){
+ private void buildLeaf(TermNode<Feature> featureNode){
if(featureNode.getTerm() == null){
throw new IllegalArgumentException("The given feature node does not have a feature.");
}
*/
private void buildBranch(){
if(getParent() == null){
- FeatureNode<Feature> parentFeatureNode = getFeatureNode().getParent();
+ TermNode<Feature> parentFeatureNode = getFeatureNode().getParent();
if(parentFeatureNode.isRoot()){
containerTree.getRoot().addChild(this);
*
* @param featureNode a {@link eu.etaxonomy.cdm.model.term.FeatureNode} object.
*/
- public void setFeatureNode(FeatureNode<Feature> featureNode) {
+ public void setFeatureNode(TermNode<Feature> featureNode) {
this.featureNode = featureNode;
}
*
* @return a {@link eu.etaxonomy.cdm.model.term.FeatureNode} object.
*/
- public FeatureNode<Feature> getFeatureNode() {
+ public TermNode<Feature> getFeatureNode() {
return featureNode;
}
import eu.etaxonomy.cdm.model.description.DescriptionBase;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermTree;
/**
* @author n.hoffmann
* @created Dec 2, 2010
- * @version 1.0
*/
public class FeatureNodeContainerTree {
}
};
- private Set<FeatureNodeContainer> featureNodeContainers = new HashSet<FeatureNodeContainer>();
+ private Set<FeatureNodeContainer> featureNodeContainers = new HashSet<>();
private FeatureNodeContainer root;
private DescriptionBase description;
- private FeatureTree featureTree;
+ private TermTree<Feature> featureTree;
- public FeatureNodeContainerTree(DescriptionBase description, FeatureTree featureTree){
+ public FeatureNodeContainerTree(DescriptionBase description, TermTree<Feature> featureTree){
this.description = description;
this.featureTree = featureTree;
* or null if there are no elements.
*/
public void buildTree(){
- List<FeatureNode> children = featureTree.getRootChildren();
+ List<TermNode<Feature>> children = featureTree.getRootChildren();
// if(description.getElements().isEmpty()){
// return;
// }
- for(FeatureNode featureNode : children){
+ for(TermNode<Feature> featureNode : children){
root.findLeaves(featureNode);
}
}
return null;
}
- public FeatureNodeContainer getFeatureNodeContainer(FeatureNode featureNode){
+ public FeatureNodeContainer getFeatureNodeContainer(TermNode<Feature> featureNode){
List<FeatureNodeContainer> leafs = root.getLeafs();
for(FeatureNodeContainer container : leafs){
return description;
}
- public FeatureTree getFeatureTree() {
+ public TermTree<Feature> getFeatureTree() {
return featureTree;
}
import org.eclipse.swt.widgets.Control;
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.featuretree.FeatureTreeContentProvider;
import eu.etaxonomy.taxeditor.featuretree.FeatureTreeLabelProvider;
import eu.etaxonomy.taxeditor.l10n.Messages;
*
* @author n.hoffmann
* @created Sep 16, 2010
- * @version 1.0
*/
public class DefaultFeatureTreePreferenecs extends CdmPreferencePage {
- private FeatureTree defaultFeatureTreeForTextualDescription;
- private FeatureTree defaultFeatureTreeForStructuredDescription;
+ private TermTree<Feature> defaultFeatureTreeForTextualDescription;
+ private TermTree<Feature> defaultFeatureTreeForStructuredDescription;
/** {@inheritDoc} */
@Override
setApply(true);
IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
- defaultFeatureTreeForTextualDescription = (FeatureTree) selection.getFirstElement();
+ defaultFeatureTreeForTextualDescription = (TermTree<Feature>)selection.getFirstElement();
}
});
- List<FeatureTree> input = CdmStore.getService(IFeatureTreeService.class).list(FeatureTree.class, null, null, null, null);
+ List<TermTree<Feature>> input = (List)CdmStore.getService(IFeatureTreeService.class).list(TermTree.class, null, null, null, null);
viewer.setInput(input);
setApply(true);
IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
- defaultFeatureTreeForStructuredDescription = (FeatureTree) selection.getFirstElement();
+ defaultFeatureTreeForStructuredDescription = (TermTree<Feature>) selection.getFirstElement();
}
});
- List<FeatureTree> input = CdmStore.getService(IFeatureTreeService.class).list(FeatureTree.class, null, null, null, null);
+ List<TermTree<Feature>> input = (List)CdmStore.getService(IFeatureTreeService.class).list(TermTree.class, null, null, null, null);
viewer.setInput(input);
import eu.etaxonomy.cdm.model.common.ICdmBase;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.MarkerType;
+import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.metadata.CdmPreference;
import eu.etaxonomy.cdm.model.metadata.CdmPreference.PrefKey;
import eu.etaxonomy.cdm.model.metadata.IPreferencePredicate;
import eu.etaxonomy.cdm.model.metadata.PreferenceSubject;
import eu.etaxonomy.cdm.model.metadata.TermDisplayEnum;
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
import eu.etaxonomy.cdm.model.term.IDefinedTerm;
import eu.etaxonomy.cdm.model.term.ISimpleTerm;
import eu.etaxonomy.cdm.model.term.TermBase;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy;
import eu.etaxonomy.cdm.strategy.match.FieldMatcher;
import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
return false;
}
- public static FeatureTree getDefaultFeatureTreeForTextualDescription() {
+ public static TermTree<Feature> getDefaultFeatureTreeForTextualDescription() {
String uuidString = getStringValue(
FEATURE_TREE_DEFAULT_TEXT);
if (StringUtils.isBlank(uuidString)) {
return null;
}
- FeatureTree tree = CdmStore.getService(
+ TermTree<Feature> tree = CdmStore.getService(
IFeatureTreeService.class).load(UUID.fromString(uuidString));
if (tree.getId() == 0) {
return null;
return tree;
}
- public static FeatureTree getDefaultFeatureTreeForStructuredDescription() {
+ public static TermTree<Feature> getDefaultFeatureTreeForStructuredDescription() {
String uuidString = getStringValue(
FEATURE_TREE_DEFAULT_STRUCTURE);
- return CdmUtils.isEmpty(uuidString) ? null : CdmStore.getService(
+ return StringUtils.isBlank(uuidString) ? null : CdmStore.getService(
IFeatureTreeService.class).load(UUID.fromString(uuidString));
}
false);
}
- /* (non-Javadoc)
- * @see eu.etaxonomy.taxeditor.preference.menu.AbstractMenuPreferences#getTermClass()
- */
/** {@inheritDoc} */
@Override
protected TermType getTermType() {
@Override
protected List<Feature> getTerms(){
if(CdmStore.isActive() ){
- List<Feature> termList = new ArrayList(TermEditorInput.getDefaultNameFeatureTree().getDistinctFeatures());
+ List<Feature> termList = new ArrayList(TermEditorInput.getDefaultNameFeatureTree().getDistinctTerms());
return termList;
}
- return new ArrayList<Feature>();
+ return new ArrayList<>();
}
}
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.model.description.DescriptionBase;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.description.PolytomousKey;
import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;
import eu.etaxonomy.cdm.model.description.DescriptiveDataSet;
else if (cdmBase instanceof EntityValidation) {
service = (IService<T>) getService(IEntityValidationService.class);
}
- else if (cdmBase instanceof FeatureNode) {
+ else if (cdmBase instanceof TermNode) {
service = (IService<T>) getService(IFeatureNodeService.class);
}
- else if (cdmBase instanceof FeatureTree) {
+ else if (cdmBase instanceof TermTree) {
service = (IService<T>) getService(IFeatureTreeService.class);
}
else if (cdmBase instanceof GrantedAuthority) {
// private final ConversationHolder conversation = null;
protected List<UuidAndTitleCache<T>> model;
- private final Set<T> transientCdmObjects = new HashSet<T>();
+ private final Set<T> transientCdmObjects = new HashSet<>();
private final String settings;
protected final Integer limitOfInitialElements = null;
- private T selectedObject;
-
protected Set<UUID> cdmBaseToBeFiltered;
protected Job searchJob;
import org.eclipse.swt.widgets.Shell;
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermType;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
import eu.etaxonomy.taxeditor.l10n.Messages;
import eu.etaxonomy.taxeditor.newWizard.AbstractNewEntityWizard;
import eu.etaxonomy.taxeditor.store.CdmStore;
* @created Sep 17, 2010
*/
public class FeatureTreeSelectionDialog extends
- AbstractFilteredCdmResourceSelectionDialog<FeatureTree> {
+ AbstractFilteredCdmResourceSelectionDialog<TermTree<Feature>> {
private final TermType termType;
- public static FeatureTree select(Shell shell,
- FeatureTree featureTree) {
+ public static TermTree<Feature> select(Shell shell,
+ TermTree<Feature> featureTree) {
return select(shell, featureTree, null);
}
- public static FeatureTree select(Shell shell,
- FeatureTree featureTree, TermType termType) {
+ public static TermTree<Feature> select(Shell shell,
+ TermTree<Feature> featureTree, TermType termType) {
FeatureTreeSelectionDialog dialog = new FeatureTreeSelectionDialog(shell,
Messages.FeatureTreeSelectionDialog_CHOOSE_TREE, false, featureTree, termType);
return getSelectionFromDialog(dialog);
protected FeatureTreeSelectionDialog(Shell shell,
String title, boolean multi,
- FeatureTree cdmObject, TermType termType) {
+ TermTree<Feature> cdmObject, TermType termType) {
super(shell, title, multi, FeatureTreeSelectionDialog.class.getCanonicalName(), cdmObject);
this.termType = termType;
}
@Override
- protected FeatureTree getPersistentObject(UUID uuid) {
+ protected TermTree<Feature> getPersistentObject(UUID uuid) {
return CdmStore.getService(IFeatureTreeService.class).load(uuid);
}
@Override
protected void callService(String pattern) {
- model = CdmStore.getService(IFeatureTreeService.class).getUuidAndTitleCacheByTermType(FeatureTree.class, termType, limitOfInitialElements, pattern);
+ model = CdmStore.getService(IFeatureTreeService.class).getUuidAndTitleCacheByTermType(TermTree.class, termType, limitOfInitialElements, pattern);
}
@Override
InputDialog dialog = new InputDialog(getShell(), Messages.FeatureTreeSelectionDialog_TREE_LABEL, Messages.FeatureTreeSelectionDialog_ENTER_LABEL, null, null);
if (dialog.open() == Window.OK) {
// User clicked OK; update the label with the input
- FeatureTree tree = null;
+ TermTree<Feature> tree = null;
if(termType!=null){
- tree = FeatureTree.NewInstance(termType);
+ tree = TermTree.NewInstance(termType);
}
else{
- tree = FeatureTree.NewInstance();
+ tree = TermTree.NewInstance();
}
tree.setTitleCache(dialog.getValue(), true);
CdmStore.getService(IFeatureTreeService.class).merge(tree,true);
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
import eu.etaxonomy.taxeditor.model.MessagingUtils;\r
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;\r
import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;\r
return (T) FeatureSelectionDialog.select(shell, //conversation,\r
(Feature) currentSelection);\r
}\r
- if(clazz.equals(FeatureTree.class)){\r
+ if(clazz.equals(TermTree.class)){\r
return (T) FeatureTreeSelectionDialog.select(shell, //conversation,\r
- (FeatureTree) currentSelection);\r
+ (TermTree) currentSelection);\r
}\r
if(clazz.equals(PolytomousKey.class)){\r
return (T) PolytomousKeySelectionDialog.select(shell, //conversation,\r
import org.eclipse.swt.widgets.Display;
import eu.etaxonomy.cdm.api.service.NaturalLanguageGenerator;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TextData;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.model.AbstractUtility;
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
import eu.etaxonomy.taxeditor.store.CdmStore;
private TaxonDescription entity;
private NaturalLanguageGenerator generator = new NaturalLanguageGenerator();
- private FeatureTree featureTree = PreferencesUtil.getDefaultFeatureTreeForStructuredDescription();
+ private TermTree<Feature> featureTree = PreferencesUtil.getDefaultFeatureTreeForStructuredDescription();
private Display display = Display.getCurrent();
public FetchNaturalLanguageDescriptionJob(String jobName, TaxonDescription entity){
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.description.Character;
+import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.term.DefinedTerm;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
import eu.etaxonomy.cdm.model.term.Representation;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.taxeditor.editor.definedterm.TermBasePropertyTester;
import eu.etaxonomy.taxeditor.model.ColorResources;
}
}
- private String getPath(FeatureNode node){
+ private String getPath(TermNode<Feature> node){
String path = node.getTerm().getLabel();
- FeatureNode parent = node.getParent();
+ TermNode<Feature> parent = node.getParent();
while(parent != null && parent.getTerm()!=null){
path = parent.getTerm().getLabel() + "/" + path;
parent = parent.getParent();
*/
package eu.etaxonomy.taxeditor.ui.section.feature;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.store.StoreUtil;
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;
* @since Dec 21, 2017
*
*/
-public class FeatureNodeDetailElement extends AbstractCdmDetailElement<FeatureNode> {
+public class FeatureNodeDetailElement extends AbstractCdmDetailElement<TermNode<Feature>> {
private InapplicableIfEntityCollectionSection sectionInapplicableIf;
private OnlyApplicableIfEntityCollectionSection sectionOnlyApplicableIf;
}
@Override
- protected void createControls(ICdmFormElement formElement, FeatureNode entity, int style) {
+ protected void createControls(ICdmFormElement formElement, TermNode<Feature> entity, int style) {
sectionInapplicableIf = formFactory.createInapplicableIfEntityCollectionSection(getConversationHolder(),
formElement, StoreUtil.getSectionStyle(InapplicableIfEntityCollectionSection.class, getEntity().getClass().getCanonicalName()));
sectionInapplicableIf.setLayoutData(LayoutConstants.FILL_HORIZONTALLY(2, 1));
import org.eclipse.jface.viewers.ISelectionProvider;
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;
import eu.etaxonomy.taxeditor.ui.section.AbstractCdmDetailElement;
* @since Dec 21, 2017
*
*/
-public class FeatureNodeDetailSection extends AbstractCdmDetailSection<FeatureNode> {
+public class FeatureNodeDetailSection extends AbstractCdmDetailSection<TermNode<Feature>> {
public FeatureNodeDetailSection(CdmFormFactory formFactory,
ConversationHolder conversation, ICdmFormElement parentElement,
@Override
public String getHeading() {
- return FeatureNode.class.getSimpleName();
+ return TermNode.class.getSimpleName();
}
/**
* {@inheritDoc}
*/
@Override
- protected AbstractCdmDetailElement<FeatureNode> createCdmDetailElement(AbstractCdmDetailSection<FeatureNode> parentElement,
+ protected AbstractCdmDetailElement<TermNode<Feature>> createCdmDetailElement(AbstractCdmDetailSection<TermNode<Feature>> parentElement,
int style) {
return formFactory.createFeatureNodeDetailElement(parentElement, style);
}
import org.eclipse.swt.widgets.Label;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.model.ColorResources;
import eu.etaxonomy.taxeditor.preference.Resources;
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
* @since Dec 21, 2017
*
*/
-public class FeatureTreeDetailElement extends AbstractIdentifiableEntityDetailElement<FeatureTree> {
+public class FeatureTreeDetailElement extends AbstractIdentifiableEntityDetailElement<TermTree<Feature>> {
public FeatureTreeDetailElement(CdmFormFactory formFactory,
ICdmFormElement formElement) {
@Override
- protected void createControls(ICdmFormElement formElement, FeatureTree entity, int style) {
+ protected void createControls(ICdmFormElement formElement, TermTree<Feature> entity, int style) {
Label lblTermType = new Label(formElement.getLayoutComposite(), style);
lblTermType.setText("Term Type");
Label lblStructureText = new Label(formElement.getLayoutComposite(), style);
import org.eclipse.jface.viewers.ISelectionProvider;
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;
import eu.etaxonomy.taxeditor.ui.section.AbstractCdmDetailElement;
* @since Dec 21, 2017
*
*/
-public class FeatureTreeDetailSection extends AbstractCdmDetailSection<FeatureTree> {
+public class FeatureTreeDetailSection extends AbstractCdmDetailSection<TermTree<Feature>> {
public FeatureTreeDetailSection(CdmFormFactory formFactory,
ConversationHolder conversation, ICdmFormElement parentElement,
@Override
public String getHeading() {
- return FeatureTree.class.getSimpleName();
+ return TermTree.class.getSimpleName();
}
/**
* {@inheritDoc}
*/
@Override
- protected AbstractCdmDetailElement<FeatureTree> createCdmDetailElement(AbstractCdmDetailSection<FeatureTree> parentElement,
+ protected AbstractCdmDetailElement<TermTree<Feature>> createCdmDetailElement(AbstractCdmDetailSection<TermTree<Feature>> parentElement,
int style) {
return formFactory.createFeatureTreeDetailElement(parentElement, style);
}
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
-import eu.etaxonomy.cdm.model.term.TermType;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.State;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.taxeditor.ui.combo.TermComboElement;
import eu.etaxonomy.taxeditor.ui.element.AbstractFormSection;
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
if(eventSource==comboState && comboState.getSelection()!=null){
if(getParentElement() instanceof InapplicableIfEntityCollectionSection){
InapplicableIfEntityCollectionSection parentElement = (InapplicableIfEntityCollectionSection) getParentElement();
- FeatureNode node = parentElement.getEntity();
+ TermNode<Feature> node = parentElement.getEntity();
node.removeInapplicableState(entity);
State state = comboState.getSelection();
node.addInapplicableState(state);
import java.util.Comparator;
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.State;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;
import eu.etaxonomy.taxeditor.ui.section.DefaultCdmBaseComparator;
* @date 06.03.2018
*
*/
-public class InapplicableIfEntityCollectionSection extends AbstractUnboundEntityCollectionSection<FeatureNode, State>{
+public class InapplicableIfEntityCollectionSection extends AbstractUnboundEntityCollectionSection<TermNode<Feature>, State>{
public InapplicableIfEntityCollectionSection(CdmFormFactory formFactory, ConversationHolder conversation,
ICdmFormElement parentElement, int style) {
* {@inheritDoc}
*/
@Override
- protected Collection<State> getEntityCollection(FeatureNode entity) {
+ protected Collection<State> getEntityCollection(TermNode<Feature> entity) {
return entity.getInapplicableIf();
}
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
-import eu.etaxonomy.cdm.model.term.TermType;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.State;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.taxeditor.ui.combo.TermComboElement;
import eu.etaxonomy.taxeditor.ui.element.AbstractFormSection;
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
if(eventSource==comboState && comboState.getSelection()!=null){
if(getParentElement() instanceof OnlyApplicableIfEntityCollectionSection){
OnlyApplicableIfEntityCollectionSection parentElement = (OnlyApplicableIfEntityCollectionSection) getParentElement();
- FeatureNode node = parentElement.getEntity();
+ TermNode<Feature> node = parentElement.getEntity();
node.removeApplicableState(entity);
State state = comboState.getSelection();
node.addApplicableState(state);
import java.util.Comparator;
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
+import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.State;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;
import eu.etaxonomy.taxeditor.ui.section.DefaultCdmBaseComparator;
* @date 06.03.2018
*
*/
-public class OnlyApplicableIfEntityCollectionSection extends AbstractUnboundEntityCollectionSection<FeatureNode, State>{
+public class OnlyApplicableIfEntityCollectionSection extends AbstractUnboundEntityCollectionSection<TermNode<Feature>, State>{
public OnlyApplicableIfEntityCollectionSection(CdmFormFactory formFactory, ConversationHolder conversation,
ICdmFormElement parentElement, int style) {
* {@inheritDoc}
*/
@Override
- protected Collection<State> getEntityCollection(FeatureNode entity) {
+ protected Collection<State> getEntityCollection(TermNode<Feature> entity) {
return entity.getOnlyApplicableIf();
}
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.model.term.FeatureNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
import eu.etaxonomy.taxeditor.editor.IDistributionEditor;
if(input instanceof GbifResponse){
input = ((GbifResponse) input).getDerivedUnitFacade();
}
- if(input instanceof FeatureNode
- && HibernateProxyHelper.isInstanceOf(((FeatureNode) input).getTerm(), Character.class)){
- input = HibernateProxyHelper.deproxy(((FeatureNode) input).getTerm(), Character.class);
+ if(input instanceof TermNode
+ && HibernateProxyHelper.isInstanceOf(((TermNode) input).getTerm(), Character.class)){
+ input = HibernateProxyHelper.deproxy(((TermNode) input).getTerm(), Character.class);
}
if (input !=null && input.getClass().equals(DerivedUnit.class)) {
DerivedUnit derivedUnit = (DerivedUnit)input;
else if (input instanceof FeatureNodeContainer) {
createFeatureDistributionSection(rootElement);
- } else if (input instanceof FeatureNode) {
+ } else if (input instanceof TermNode) {
createFeatureNodeSection(rootElement);
- } else if (input instanceof FeatureTree) {
+ } else if (input instanceof TermTree) {
createFeatureTreeSection(rootElement);
} else if (input instanceof Character) {