4 package eu
.etaxonomy
.taxeditor
.editor
.name
;
6 import java
.util
.ArrayList
;
7 import java
.util
.HashSet
;
12 import eu
.etaxonomy
.cdm
.hibernate
.HibernateProxyHelper
;
13 import eu
.etaxonomy
.cdm
.model
.name
.HomotypicalGroup
;
14 import eu
.etaxonomy
.cdm
.model
.taxon
.Synonym
;
15 import eu
.etaxonomy
.cdm
.model
.taxon
.Taxon
;
16 import eu
.etaxonomy
.cdm
.model
.taxon
.TaxonBase
;
17 import eu
.etaxonomy
.cdm
.model
.taxon
.TaxonRelationship
;
18 import eu
.etaxonomy
.cdm
.model
.taxon
.TaxonRelationshipType
;
21 * <p>ContainerFactory class.</p>
26 public class ContainerFactory
{
28 /** Constant <code>ACCEPTED=1</code> */
29 public static final int ACCEPTED
= 1;
30 /** Constant <code>SYNONYM=2</code> */
31 public static final int SYNONYM
= 2;
32 /** Constant <code>MISAPPLICATION=3</code> */
33 public static final int MISAPPLICATION
= 3;
34 /** Constant <code>CONCEPT=4</code> */
35 public static final int CONCEPT
= 4;
37 private static ContainerFactory instance
= new ContainerFactory();
39 private ContainerFactory(){}
42 * <p>Getter for the field <code>instance</code>.</p>
44 * @return a {@link eu.etaxonomy.taxeditor.editor.name.ContainerFactory} object.
46 public static synchronized ContainerFactory
getInstance(){
51 * <p>createAcceptedTaxonsHomotypicGroup</p>
53 * @param taxonNameEditor a {@link eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor} object.
55 public void createAcceptedTaxonsHomotypicGroup(TaxonNameEditor taxonNameEditor
) {
56 Taxon taxon
= taxonNameEditor
.getTaxon();
58 // Draw homotypic group synonyms
59 HomotypicalGroup homotypicGroup
= (HomotypicalGroup
) HibernateProxyHelper
.deproxy(taxon
.getHomotypicGroup());
60 List
<Synonym
> homotypicSynonyms
= homotypicGroup
.getSynonymsInGroup(taxon
.getSec());
62 HomotypicalSynonymGroup group
= taxonNameEditor
.getHomotypicSynonymGroup();
64 // check if the taxon has changed
65 if(group
!= null && ! taxon
.getHomotypicGroup().equals(group
.getGroup()) ){
66 group
.removeAllContainers();
73 HomotypicalSynonymGroup homotypicalSynonymGroup
= new HomotypicalSynonymGroup(taxonNameEditor
, homotypicGroup
);
74 taxonNameEditor
.setHomotypicSynonymGroup(homotypicalSynonymGroup
);
75 AcceptedNameContainer acceptedNameContainer
= new AcceptedNameContainer(taxonNameEditor
, homotypicalSynonymGroup
);
77 taxonNameEditor
.setAcceptedNameContainer(acceptedNameContainer
);
78 for(Synonym synonym
: homotypicSynonyms
){
79 createContainerFactoryMethod(SYNONYM
, homotypicalSynonymGroup
, synonym
, taxonNameEditor
);
84 fillGroup(group
, homotypicSynonyms
, ACCEPTED
, taxonNameEditor
);
89 * <p>createHeterotypicSynonymGroups</p>
91 * @param taxonNameEditor a {@link eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor} object.
93 public void createHeterotypicSynonymGroups(TaxonNameEditor taxonNameEditor
) {
94 Taxon taxon
= taxonNameEditor
.getTaxon();
96 List
<HomotypicalGroup
> homotypicalGroups
= taxon
.getHeterotypicSynonymyGroups();
98 // reatins a reference to the homotypical group widgets
99 Map
<HomotypicalGroup
, HomotypicalSynonymGroup
> retainedGroups
= taxonNameEditor
.getHeterotypicSynonymGroupsMap();
101 taxonNameEditor
.clearHeterotypicSynonymGroups();
103 // iterate over taxas synonymy groups
104 for (HomotypicalGroup homotypicalGroup
: homotypicalGroups
) {
105 HomotypicalGroup homotypicalGroupDeproxied
= (HomotypicalGroup
) HibernateProxyHelper
.deproxy(homotypicalGroup
);
107 HomotypicalSynonymGroup group
;
108 if(retainedGroups
.containsKey(homotypicalGroupDeproxied
)){
109 group
= retainedGroups
.get(homotypicalGroupDeproxied
);
110 retainedGroups
.remove(homotypicalGroupDeproxied
);
112 group
= new HomotypicalSynonymGroup(taxonNameEditor
, homotypicalGroupDeproxied
);
115 createHeterotypicSynonymGroup(taxonNameEditor
, group
);
116 taxonNameEditor
.addHeterotypicSynonymGroup(group
);
119 // remove all groups that did not match
120 for(AbstractGroup group
: retainedGroups
.values()){
126 * <p>createMisapplicationGroup</p>
128 * @param taxonNameEditor a {@link eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor} object.
130 public void createMisapplicationGroup(TaxonNameEditor taxonNameEditor
) {
131 Taxon taxon
= taxonNameEditor
.getTaxon();
133 List
<TaxonBase
> content
= new ArrayList
<TaxonBase
>(taxon
.getMisappliedNames());
135 if(content
.size() == 0 && taxonNameEditor
.getMisappliedGroup() != null){
136 taxonNameEditor
.getMisappliedGroup().clear();
137 taxonNameEditor
.setMisapplicationsGroup(null);
139 AbstractGroup group
= getMisappliedGroup(taxonNameEditor
);
140 fillGroup(group
, content
, MISAPPLICATION
, taxonNameEditor
);
145 * <p>createConceptGroup</p>
147 * @param taxonNameEditor a {@link eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor} object.
149 public void createConceptGroup(TaxonNameEditor taxonNameEditor
) {
150 Taxon taxon
= taxonNameEditor
.getTaxon();
152 Set
<TaxonRelationship
> filteredTaxonRelations
= new HashSet
<TaxonRelationship
>();
154 for (TaxonRelationship relationship
: taxon
.getTaxonRelations()) {
155 if (! relationship
.getType().equals(TaxonRelationshipType
.MISAPPLIED_NAME_FOR()) ||
156 relationship
.getType().equals(TaxonRelationshipType
.TAXONOMICALLY_INCLUDED_IN())) {
157 filteredTaxonRelations
.add(relationship
);
161 if(filteredTaxonRelations
.size() == 0 && taxonNameEditor
.getConceptGroup() != null){
162 taxonNameEditor
.getConceptGroup().clear();
163 taxonNameEditor
.setConceptGroup(null);
165 ConceptGroup group
= getConceptGroup(taxonNameEditor
);
167 // reatain old container
168 List
<AbstractGroupedContainer
<Taxon
>> groupedContainers
= group
.getGroupedContainers();
170 group
.removeAllContainers();
172 // Draw concept relation elements
173 for (TaxonRelationship relationship
: filteredTaxonRelations
) {
174 ConceptContainer
.getNewInstance(group
.getNameEditor(), group
, relationship
);
183 * @param group a {@link eu.etaxonomy.taxeditor.editor.name.AbstractGroup} object.
184 * @param content a {@link java.util.List} object.
186 * @param taxonNameEditor
188 public void fillGroup(AbstractGroup group
, List
<?
extends TaxonBase
> content
, int mode
, TaxonNameEditor taxonNameEditor
){
189 if(content
== null || (mode
!= ACCEPTED
&& content
.size() == 0)){
193 AbstractGroupedContainer
[] retainedContainers
= (AbstractGroupedContainer
[]) group
.getGroupedContainers().toArray(new AbstractGroupedContainer
[0]);
195 group
.clearContainers();
197 if(retainedContainers
.length
> 0 && retainedContainers
[0] instanceof AcceptedNameContainer
){
198 group
.add(retainedContainers
[0]);
199 retainedContainers
[0] = null;
202 for(TaxonBase taxonBase
: content
){
203 AbstractGroupedContainer existingContainer
= null;
205 for(AbstractGroupedContainer container
: retainedContainers
){
206 if(container
!= null && taxonBase
.equals(container
.getData())){
207 existingContainer
= container
;
208 retainedContainers
[i
] = null;
212 if(existingContainer
!= null){
213 group
.add(existingContainer
);
215 createContainerFactoryMethod(mode
== ACCEPTED ? SYNONYM
: mode
, group
, taxonBase
, taxonNameEditor
);
219 // delete all container that were not used
220 for(AbstractGroupedContainer container
: retainedContainers
){
221 if(container
!= null){
222 group
.deleteContainer(container
);
228 * <p>createContainerFactoryMethod</p>
231 * @param group a {@link eu.etaxonomy.taxeditor.editor.name.AbstractGroup} object.
232 * @param taxonBase a {@link eu.etaxonomy.cdm.model.taxon.TaxonBase} object.
233 * @param taxonNameEditor
234 * @return a {@link eu.etaxonomy.taxeditor.editor.name.AbstractGroupedContainer} object.
236 public AbstractGroupedContainer
createContainerFactoryMethod(int mode
, AbstractGroup group
, TaxonBase taxonBase
, TaxonNameEditor taxonNameEditor
){
237 AbstractGroupedContainer container
= null;
241 container
= new AcceptedNameContainer(group
.getNameEditor(), group
);
244 container
= new SynonymContainer(group
.getNameEditor(), group
, (Synonym
) taxonBase
);
247 container
= new MisapplicationContainer(group
.getNameEditor(), group
, (Taxon
) taxonBase
);
253 taxonNameEditor
.getManagedForm().addPart(container
);
259 * <p>createHeterotypicSynonymGroup</p>
261 * @param taxonNameEditor a {@link eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor} object.
262 * @param group a {@link eu.etaxonomy.taxeditor.editor.name.HomotypicalSynonymGroup} object.
264 public void createHeterotypicSynonymGroup(TaxonNameEditor taxonNameEditor
, HomotypicalSynonymGroup group
) {
265 Taxon taxon
= taxonNameEditor
.getTaxon();
267 List
<AbstractGroupedContainer
<Synonym
>> groupedContainers
= group
.getGroupedContainers();
269 List
<Synonym
> heterotypicSynonyms
= group
.getGroup().getSynonymsInGroup(taxon
.getSec());
271 fillGroup(group
, heterotypicSynonyms
, SYNONYM
, taxonNameEditor
);
275 private MisappliedGroup
getMisappliedGroup(TaxonNameEditor editor
) {
276 if(editor
.getMisappliedGroup() == null){
277 // Create the group composite
278 editor
.setMisapplicationsGroup(new MisappliedGroup(editor
));
281 MisappliedGroup misappliedGroup
= editor
.getMisappliedGroup();
283 // Put the group composite before concept group composite, if any
284 if (editor
.getConceptGroup() != null) {
285 editor
.getMisappliedGroup().getControl().moveAbove(editor
.getConceptGroup().getControl());
288 return misappliedGroup
;
292 private ConceptGroup
getConceptGroup(TaxonNameEditor editor
) {
293 if(editor
.getConceptGroup() == null){
294 // Create the group composite
295 editor
.setConceptGroup(new ConceptGroup(editor
));
298 ConceptGroup conceptGroup
= editor
.getConceptGroup();
300 // Put the group composite after misapplied group composite, if any
301 if (editor
.getMisappliedGroup() != null) {
302 editor
.getConceptGroup().getControl().moveBelow(editor
.getMisappliedGroup().getControl());