import org.eclipse.swt.widgets.Tree;
import eu.etaxonomy.cdm.model.common.TermType;
+import eu.etaxonomy.cdm.model.description.Character;
import eu.etaxonomy.cdm.model.description.FeatureTree;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.persistence.dto.TermDto;
private Text txtDescriptiveDataSet;
private TermUuidComboViewer comboRankMin;
private TermUuidComboViewer comboRankMax;
- private FeatureTreeEditorComposite featureTreeEditorComposite;
+ private FeatureTreeEditorComposite<Character> featureTreeEditorComposite;
private TreeViewer taxonNodeTree;
private List<TermDto> areas = new ArrayList<>();
private Text textAreaText;
btnChooseArea = new Button(composite, SWT.NONE);
btnChooseArea.setImage(ImageResources.getImage(ImageResources.BROWSE_ICON));
- featureTreeEditorComposite = new FeatureTreeEditorComposite(this, SWT.NONE);
+ featureTreeEditorComposite = new FeatureTreeEditorComposite<Character>(this, SWT.NONE);
featureTreeEditorComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));
}
comboRankMax.setElement(max);
}
- public FeatureTreeEditorComposite getFeatureTreeEditorComposite() {
+ public FeatureTreeEditorComposite<Character> getFeatureTreeEditorComposite() {
return featureTreeEditorComposite;
}
- public FeatureTree getCharacters(){
+ public FeatureTree<Character> getCharacters(){
return featureTreeEditorComposite.getFeatureTree();
}
- public void setCharacters(FeatureTree characters) {
+ public void setCharacters(FeatureTree<Character> characters) {
featureTreeEditorComposite.setSelectedTree(characters);
}
import eu.etaxonomy.cdm.api.service.ITermService;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.TermType;
+import eu.etaxonomy.cdm.model.description.Character;
import eu.etaxonomy.cdm.model.description.DescriptiveDataSet;
import eu.etaxonomy.cdm.model.description.FeatureTree;
import eu.etaxonomy.cdm.model.location.NamedArea;
}
}
}
- FeatureTree characters = composite.getCharacters();
+ FeatureTree<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));
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
import eu.etaxonomy.cdm.api.service.ITermService;
import eu.etaxonomy.cdm.api.service.IVocabularyService;
+import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.Representation;
import eu.etaxonomy.cdm.model.common.TermType;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
public class CharacterEditor implements IFeatureTreeEditor,IConversationEnabled, ISelectionChangedListener,
ModifyListener, IE4ViewerPart, IPartContentHasDetails, IPartContentHasSupplementalData, IDirtyMarkable {
- private FeatureTreeEditorComposite characterTreeEditorComposite;
- private FeatureTreeEditorComposite propertiesTreeEditorComposite;
- private FeatureTreeEditorComposite structuresTreeEditorComposite;
+ private FeatureTreeEditorComposite<Character> characterTreeEditorComposite;
+ private FeatureTreeEditorComposite<DefinedTermBase> propertiesTreeEditorComposite;
+ private FeatureTreeEditorComposite<DefinedTermBase> structuresTreeEditorComposite;
private final FormToolkit formToolkit = new FormToolkit(Display.getDefault());
@Inject
Collection<Character> characters = createCharacters((TreeSelection)structureTreeSelection, (TreeSelection)propertyTreeSelection);
for (Character character : characters) {
//add new Character to feature tree
- FeatureNode parent = ((FeatureTree) characterTreeEditorComposite.getViewer().getInput()).getRoot();
+ FeatureNode<Character> parent = ((FeatureTree<Character>) characterTreeEditorComposite.getViewer().getInput()).getRoot();
vocabulary.addTerm(character);
CdmStore.getService(IFeatureNodeService.class).createChildFeatureNode(parent, character);
}
}
- private FeatureTreeEditorComposite addFeatureTreeEditor(Composite composite_3) {
- FeatureTreeEditorComposite featureTreeEditorComposite = new FeatureTreeEditorComposite(composite_3, SWT.NONE);
+ private <T extends DefinedTermBase> FeatureTreeEditorComposite<T> addFeatureTreeEditor(Composite composite_3) {
+ FeatureTreeEditorComposite<T> featureTreeEditorComposite = new FeatureTreeEditorComposite<>(composite_3, SWT.NONE);
featureTreeEditorComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
return featureTreeEditorComposite;
}
public static Collection<Character> createCharacters(TreeSelection structureTreeSelection, TreeSelection propertyTreeSelection){
Set<Character> characters = new HashSet<>();
//get selected structures and properties
- Iterator<FeatureNode> structureIterator = structureTreeSelection.iterator();
+ Iterator<FeatureNode<DefinedTermBase>> structureIterator = structureTreeSelection.iterator();
//create all combinations of structures and properties
while(structureIterator.hasNext()){
- FeatureNode structureNode = structureIterator.next();
- Iterator<FeatureNode> propertiesIterator = propertyTreeSelection.iterator();
+ FeatureNode<DefinedTermBase> structureNode = structureIterator.next();
+ Iterator<FeatureNode<DefinedTermBase>> propertiesIterator = propertyTreeSelection.iterator();
while(propertiesIterator.hasNext()){
- FeatureNode propertyNode = propertiesIterator.next();
+ FeatureNode<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 featureTree = characterTreeEditorComposite.getFeatureTree();
+ FeatureTree<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));
}
@Override
- public List<FeatureTree> getRootEntities() {
- List<FeatureTree> root = new ArrayList<>();
+ public List<FeatureTree<Character>> getRootEntities() {
+ List<FeatureTree<Character>> root = new ArrayList<>();
root.add(characterTreeEditorComposite.getFeatureTree());
return root;
}
return (IStructuredSelection) characterTreeEditorComposite.getViewer().getSelection();
}
- public FeatureTree getCharacterTree(){
+ public FeatureTree<Character> getCharacterTree(){
return characterTreeEditorComposite.getFeatureTree();
}
}
private class FeatureTreeChooserListener extends SelectionAdapter{
- private FeatureTreeEditorComposite featureTreeEditorComposite;
+ private FeatureTreeEditorComposite<?> featureTreeEditorComposite;
private TermType termType;
- public FeatureTreeChooserListener(FeatureTreeEditorComposite featureTreeEditorComposite, TermType termType) {
+ public FeatureTreeChooserListener(FeatureTreeEditorComposite<?> featureTreeEditorComposite, TermType termType) {
super();
this.featureTreeEditorComposite = featureTreeEditorComposite;
this.termType = termType;
import eu.etaxonomy.cdm.api.service.dto.RowWrapperDTO;
import eu.etaxonomy.cdm.api.service.dto.SpecimenRowWrapperDTO;
import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;
-import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.description.Character;
import eu.etaxonomy.cdm.model.description.DescriptionBase;
import eu.etaxonomy.cdm.model.description.DescriptiveDataSet;
natTable.doCommand(new ClientAreaResizeCommand(natTable));
}
- private List<Character> initCharacterList(FeatureNode node){
+ private List<Character> initCharacterList(FeatureNode<Character> node){
List<Character> characters = new ArrayList<>();
node.getChildNodes().forEach(childNode->
{
- DefinedTermBase term = childNode.getTerm();
- // FIXME #8146 this is currently checked via the termType of the tree
- // in the init() method. This may be solved by adding generics to FeatureNode
- // so that getTerm is typified. This would make this check obsolete
- if(term.isInstanceOf(Character.class)){
- characters.add(HibernateProxyHelper.deproxy(term, Character.class));
- }
+ characters.add(childNode.getTerm());
characters.addAll(initCharacterList(childNode));
});
return characters;
public void initDescriptiveDataSet(DescriptiveDataSet descriptiveDataSet){
this.descriptiveDataSet = descriptiveDataSet;
//get features/columns stored in descriptive data set
- FeatureTree tree = descriptiveDataSet.getDescriptiveSystem();
+ FeatureTree<Character> tree = descriptiveDataSet.getDescriptiveSystem();
characters = initCharacterList(tree.getRoot());
//init state data for categorical features
Object selectedElement = selection.getFirstElement();
if (selectedElement instanceof DescriptionBase<?>) {
- FeatureTree featureTree = getFeatureTree((DescriptionBase<?>) selectedElement);
+ FeatureTree<?> featureTree = getFeatureTree((DescriptionBase<?>) selectedElement);
- for (FeatureNode childNode : featureTree.getRootChildren()) {
+ for (FeatureNode<?> childNode : featureTree.getRootChildren()) {
createMenuItem(menu, childNode.getTerm(), globalLanguage);
}
} else if (selectedElement instanceof FeatureNodeContainer) {
- FeatureNode featureNode = ((FeatureNodeContainer) selectedElement)
+ FeatureNode<?> 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 (FeatureNode<?> 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 FeatureTree<?> getFeatureTree(DescriptionBase description) {
+ FeatureTree<?> featureTree = null;
// TODO change this to the feature tree associated with this taxon
// description
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Tree;
+import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.TermType;
import eu.etaxonomy.cdm.model.description.FeatureTree;
import eu.etaxonomy.taxeditor.editor.definedterm.TermTransfer;
* @since Jun 19, 2017
*
*/
-public class FeatureTreeEditorComposite extends Composite{
+public class FeatureTreeEditorComposite <T extends DefinedTermBase> extends Composite{
- private FeatureTree featureTree;
+ private FeatureTree<T> featureTree;
private Label label_title;
private Text text_title;
btnOpenFeatureTree.addSelectionListener(new SelectionAdapter(){
@Override
public void widgetSelected(SelectionEvent e) {
- FeatureTree tree = FeatureTreeSelectionDialog.select(getDisplay().getActiveShell(),
+ FeatureTree<T> tree = FeatureTreeSelectionDialog.select(getDisplay().getActiveShell(),
null, termType);
if(tree!=null){
setSelectedTree(tree);
}
}
- public void setSelectedTree(FeatureTree featureTree) {
+ public void setSelectedTree(FeatureTree<T> featureTree) {
this.featureTree = featureTree;
viewer.setInput(featureTree);
}
}
- public FeatureTree getFeatureTree() {
+ public FeatureTree<T> getFeatureTree() {
return featureTree;
}
- private FeatureNode featureNode;
+ private FeatureNode<Feature> featureNode;
private List<FeatureNodeContainer> children = new ArrayList<FeatureNodeContainer>();
private List<DescriptionElementBase> descriptionElements = new ArrayList<DescriptionElementBase>();
* @param description
* @return
*/
- protected void findLeaves(FeatureNode featureNode) {
+ protected void findLeaves(FeatureNode<Feature> featureNode) {
if(featureNode.isLeaf()){
buildLeaf(featureNode);
}else{
- for(FeatureNode childNode : featureNode.getChildNodes()){
+ for(FeatureNode<Feature> childNode : featureNode.getChildNodes()){
findLeaves(childNode);
}
}
* @param description
* @return
*/
- private void buildLeaf(FeatureNode featureNode){
- if(featureNode.getFeature() == null){
+ private void buildLeaf(FeatureNode<Feature> featureNode){
+ if(featureNode.getTerm() == null){
throw new IllegalArgumentException("The given feature node does not have a feature.");
}
- Feature feature = (Feature) HibernateProxyHelper.deproxy(featureNode.getFeature());
+ Feature feature = HibernateProxyHelper.deproxy(featureNode.getTerm());
// get feature node container for the given feature
FeatureNodeContainer container = containerTree.getFeatureNodeContainer(feature);
*/
private void buildBranch(){
if(getParent() == null){
- FeatureNode parentFeatureNode = getFeatureNode().getParent();
+ FeatureNode<Feature> parentFeatureNode = getFeatureNode().getParent();
if(parentFeatureNode.isRoot()){
containerTree.getRoot().addChild(this);
*
* @param featureNode a {@link eu.etaxonomy.cdm.model.description.FeatureNode} object.
*/
- public void setFeatureNode(FeatureNode featureNode) {
+ public void setFeatureNode(FeatureNode<Feature> featureNode) {
this.featureNode = featureNode;
}
*
* @return a {@link eu.etaxonomy.cdm.model.description.FeatureNode} object.
*/
- public FeatureNode getFeatureNode() {
+ public FeatureNode<Feature> getFeatureNode() {
return featureNode;
}
*/
public Feature getFeature(){
if(featureNode != null){
- return featureNode.getFeature();
+ return featureNode.getTerm();
}
return null;
}