Project

General

Profile

« Previous | Next » 

Revision 4ca3e4f3

Added by Patrick Plitzner about 6 years ago

ref #7095 correctly sort tree hierarchy via taxon nodes sort prefs

View differences:

eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/workingSet/matrix/DescriptionTreeFormat.java
10 10
package eu.etaxonomy.taxeditor.editor.workingSet.matrix;
11 11

  
12 12
import java.util.Comparator;
13
import java.util.HashMap;
14 13
import java.util.List;
15
import java.util.Map;
16 14
import java.util.Set;
17 15

  
18 16
import ca.odell.glazedlists.TreeList;
19 17
import eu.etaxonomy.cdm.model.taxon.Taxon;
18
import eu.etaxonomy.cdm.model.taxon.TaxonNaturalComparator;
20 19
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
20
import eu.etaxonomy.cdm.model.taxon.TaxonNodeByNameComparator;
21
import eu.etaxonomy.cdm.model.taxon.TaxonNodeByRankAndNameComparator;
22
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
21 23

  
22 24
/**
23 25
 * @author pplitzner
24 26
 * @date 23.01.2018
25 27
 *
26 28
 */
27
/*
28
 * Using a String directly as the tree item has the possible disadvantage of
29
 * haven non-unique items in the tree within subtrees.
30
 */
31 29
 public class DescriptionTreeFormat implements TreeList.Format<Object> {
32 30

  
33
     private Map parentMapping = new HashMap<>();
31
     private Comparator<TaxonNode> comparator;
32

  
33
     public DescriptionTreeFormat() {
34
         if (PreferencesUtil.getSortNodesNaturally()){
35
             comparator = new TaxonNaturalComparator();
36
         } else if (PreferencesUtil.getSortNodesStrictlyAlphabetically()){
37
             comparator = new TaxonNodeByNameComparator();
38
         }else {
39
             comparator = new TaxonNodeByRankAndNameComparator();
40
         }
41
     }
34 42

  
35
     /**
36
      * Populate path with a list describing the path from a root node to
37
      * this element. Upon returning, the list must have size >= 1, where the
38
      * provided element identical to the list's last element. This
39
      * implementation will use the first object found for a last name as
40
      * root node by storing it within a map. If there is already an object
41
      * stored for the lastname of the given element, it will be used as root
42
      * for the path.
43
      */
44 43
     @Override
45 44
     public void getPath(List path, Object element) {
46 45
         if(element instanceof RowWrapper){
......
50 49
             if(taxonNodes!=null){
51 50
                 TaxonNode node = taxonNodes.iterator().next();
52 51
                 addPathRecursive(path, node);
53
//                 Object rowWrapperParentNode = parentMapping.get(node);
54
//                 if(rowWrapperParentNode!=null){
55
//                     path.add(rowWrapperParentNode);
56
//                 }
57
//                 else{
58
//                     TaxonNode parentNode = HibernateProxyHelper.deproxy(node.getParent(), TaxonNode.class);
59
//                     while(parentNode!=null){
60
//                         path.add(parentNode);
61
//                         parentMapping.put(node, parentNode);
62
//                         if(parentNode instanceof TaxonNode){
63
//                             if(parentMapping.get(parentNode)!=null){
64
//                                 path.add(parentMapping).get(parentNode);
65
//                             }
66
//                             else{
67
//                                 parentNode = HibernateProxyHelper.deproxy(parentNode.getParent(), TaxonNode.class);
68
//                             }
69
//                         }
70
//                     }
71
//                 }
72 52
             }
73 53
         }
74 54
         path.add(element);
......
81 61
         }
82 62
     }
83 63

  
84
     /**
85
      * Simply always return true.
86
      *
87
      * @return true if this element can have child elements, or
88
      *         false if it is always a leaf node.
89
      */
90 64
     @Override
91 65
     public boolean allowsChildren(Object element) {
92
         return true;
66
         if(element instanceof TaxonNode){
67
             return true;
68
         }
69
         return false;
93 70
     }
94 71

  
95
     /**
96
      * Returns the comparator used to order path elements of the specified
97
      * depth. If enforcing order at this level is not intended, this method
98
      * should return null. We do a simple sorting of the last
99
      * names of the persons to show so the tree nodes are sorted in
100
      * alphabetical order.
101
      */
102 72
     @Override
103 73
     public Comparator<Object> getComparator(int depth) {
104 74
         return new Comparator<Object>() {
105 75

  
106 76
             @Override
107 77
             public int compare(Object o1, Object o2) {
108
//                 if(o1 instanceof RowWrapper && o2 instanceof RowWrapper){
109
//                     return ((RowWrapper) o1).getSpecimenDescription().getId()-(((RowWrapper) o2).getSpecimenDescription().getId());
110
//                 }
111
//                 else
112
                     if(o1 instanceof TaxonNode && o2 instanceof TaxonNode){
113
                     return ((TaxonNode) o1).getTaxon().getName().getNameCache().compareTo(((TaxonNode) o2).getTaxon().getName().getNameCache());
78
                 if(o1 instanceof TaxonNode && o2 instanceof TaxonNode){
79
                     return comparator.compare((TaxonNode)o1, (TaxonNode)o2);
114 80
                 }
115
                 return 0;
81
                 return o1.hashCode()-o2.hashCode();
116 82
             }
117 83

  
118 84
         };

Also available in: Unified diff