taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/propertysheet/namerelations/wizard/ChooseRelationWizardPage.java

   1 /**
   2  * Copyright (C) 2007 EDIT
   3  * European Distributed Institute of Taxonomy
   4  * http://www.e-taxonomy.eu
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version 1.1
   7  * See LICENSE.TXT at the top of this package for the full license terms.
   8  */
   9
  10 package eu.etaxonomy.taxeditor.propertysheet.namerelations.wizard;
  11
  12 import java.beans.PropertyChangeEvent;
  13 import java.beans.PropertyChangeListener;
  14 import java.util.ArrayList;
  15 import java.util.List;
  16
  17 import org.eclipse.core.databinding.observable.list.WritableList;
  18 import org.eclipse.jface.wizard.WizardPage;
  19 import org.eclipse.swt.SWT;
  20 import org.eclipse.swt.events.SelectionAdapter;
  21 import org.eclipse.swt.events.SelectionEvent;
  22 import org.eclipse.swt.events.SelectionListener;
  23 import org.eclipse.swt.layout.GridData;
  24 import org.eclipse.swt.layout.GridLayout;
  25 import org.eclipse.swt.widgets.Button;
  26 import org.eclipse.swt.widgets.Combo;
  27 import org.eclipse.swt.widgets.Composite;
  28 import org.eclipse.swt.widgets.Group;
  29 import org.eclipse.swt.widgets.Label;
  30
  31 import eu.etaxonomy.cdm.model.name.NameRelationship;
  32 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
  33 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  34 import eu.etaxonomy.cdm.model.reference.ReferenceBase;
  35 import eu.etaxonomy.taxeditor.editor.labels.ILabelImageStrategy;
  36 import eu.etaxonomy.taxeditor.editor.labels.LabelImageProvider;
  37 import eu.etaxonomy.taxeditor.editor.name.NameSelectComposite;
  38 import eu.etaxonomy.taxeditor.editor.reference.ReferenceSelectComposite;
  39 import eu.etaxonomy.taxeditor.model.NameUtil;
  40 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
  41 import eu.etaxonomy.taxeditor.store.VocabularyStore;
  42
  43 /**
  44  * An all-in-one relation wizard page where the user chooses a related name, a
  45  * relationship type, and the relation's directionality.
  46  *
  47  * @author p.ciardelli
  48  * @created 04.06.2008
  49  * @version 1.0
  50  */
  51 public class ChooseRelationWizardPage extends WizardPage {
  52
  53         private List<NameRelationshipType> relationTypes;
  54
  55         private Combo typeCombo;
  56         private Label lblDirection;
  57         private Button btnFromRelatedToBase;
  58         private Button btnFromBaseToRelated;
  59
  60         private boolean typeSelected = false;
  61         private boolean directionSelected = false;
  62
  63         private SelectionListener radioSelectionListener = new SelectionAdapter() {
  64                 public void widgetSelected(SelectionEvent e) {
  65                         directionSelected = true;
  66                         if (e.widget.equals(btnFromRelatedToBase)) {
  67                                 fromName = relatedName;
  68                                 toName = baseName;
  69                         }
  70                         if (e.widget.equals(btnFromBaseToRelated)) {
  71                                 fromName = baseName;
  72                                 toName = relatedName;
  73                         }
  74                         updatePage();
  75                 }
  76         };
  77
  78         private NameSelectComposite nameComposite;
  79
  80         private boolean nameSelected;
  81
  82         private TaxonNameBase<?, ?> baseName;
  83         private TaxonNameBase<?, ?> relatedName;
  84         private TaxonNameBase<?, ?> fromName;
  85         private TaxonNameBase<?, ?> toName;
  86
  87         private NameRelationshipType type;
  88
  89         private Label lblType;
  90
  91         private ReferenceSelectComposite referenceComposite;
  92
  93         private WritableList nameRelationsList;
  94
  95         private LabelImageProvider labelProvider;
  96
  97         public ChooseRelationWizardPage(TaxonNameBase<?, ?> name, WritableList nameRelationsList) {
  98                 super("");
  99
 100                 this.baseName = name;
 101                 this.nameRelationsList = nameRelationsList;
 102
 103                 ILabelImageStrategy strategy = LabelImageProvider.getLabelStrategy(name);
 104                 this.labelProvider = new LabelImageProvider(strategy);
 105
 106                 setTitle("Create name relationship.");
 107                 setDescription("Create a relationship for  \""
 108                                 + NameUtil.getDisplayName(baseName) + "\".");
 109         }
 110
 111         public void createControl(Composite parent) {
 112                 Composite container = new Composite(parent, SWT.NULL);
 113                 container.setLayout(new GridLayout());
 114
 115                 setControl(container);
 116
 117                 // Create name input composite
 118                 nameComposite = new NameSelectComposite(container);
 119                 nameComposite.addPropertyChangeListener(new PropertyChangeListener() {
 120                         public void propertyChange(PropertyChangeEvent evt) {
 121                                 setName();
 122                         }
 123                 });
 124
 125                 // Init relation type array
 126                 relationTypes = new ArrayList<NameRelationshipType>();
 127
 128                 //
 129                 lblType = new Label(container, SWT.NONE);
 130                 lblType.setText("Choose relationship type:");
 131
 132                 // Create relation type dropdown
 133                 typeCombo = new Combo(container, SWT.BORDER);
 134                 typeCombo.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
 135                 for (NameRelationshipType relationType :
 136                                 PreferencesUtil.getPreferredNameRelationshipTypes()) {
 137
 138                         relationTypes.add(relationType);
 139                         String label = labelProvider.getNameRelationTypeLabel(relationType);
 140                         typeCombo.add(label);
 141                 }
 142                 typeCombo.setVisibleItemCount(relationTypes.size());
 143
 144                 typeCombo.addSelectionListener(new SelectionAdapter() {
 145                         @Override
 146                         public void widgetSelected(SelectionEvent e) {
 147                                 setType();
 148                         }
 149                 });
 150                 typeCombo.setEnabled(false);
 151
 152                 final Group group = new Group(container, SWT.NONE);
 153                 group.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 154                 final GridLayout gridLayout = new GridLayout();
 155                 group.setLayout(gridLayout);
 156
 157                 lblDirection = new Label(group, SWT.NONE);
 158                 final GridData gd_lblDirection = new GridData(SWT.FILL, SWT.CENTER, true, false);
 159                 gd_lblDirection.heightHint = 32;
 160                 gd_lblDirection.minimumHeight = 40;
 161                 lblDirection
 162                                 .setLayoutData(gd_lblDirection);
 163                 lblDirection.setEnabled(false);
 164                 lblDirection.setText("Choose relationship direction:");
 165
 166                 btnFromRelatedToBase = new Button(group, SWT.RADIO);
 167                 btnFromRelatedToBase
 168                                 .setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
 169                 btnFromRelatedToBase.setVisible(false);
 170                 btnFromRelatedToBase.addSelectionListener(radioSelectionListener);
 171
 172                 btnFromBaseToRelated = new Button(group, SWT.RADIO);
 173                 btnFromBaseToRelated
 174                                 .setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
 175                 btnFromBaseToRelated.setVisible(false);
 176                 btnFromBaseToRelated.addSelectionListener(radioSelectionListener);
 177                 new Label(group, SWT.NONE);
 178
 179                 // Create reference input composite
 180                 referenceComposite = new ReferenceSelectComposite(container);
 181         }
 182
 183         /**
 184          */
 185         private void setName() {
 186                 nameSelected = nameComposite.getName() == null ? false : true;
 187                 if (nameSelected) {
 188                         this.relatedName = nameComposite.getName();
 189                 } else {
 190                         this.relatedName = null;
 191                 }
 192                 updatePage();
 193         }
 194
 195         /**
 196          *
 197          */
 198         private void setType() {
 199                 int typeIndex = typeCombo.getSelectionIndex();
 200                 type = relationTypes.get(typeIndex);
 201                 typeSelected = true;
 202                 updatePage();
 203         }
 204
 205         private void setDirectionLabels() {
 206                 String strDirection1 = "\"" + NameUtil.getDisplayName(relatedName) + "\" "
 207                                 + "is " + typeCombo.getText() + " " + "\""
 208                                 + NameUtil.getDisplayName(baseName) + "\"";
 209                 String strDirection2 = "\"" + NameUtil.getDisplayName(baseName) + "\" "
 210                                 + "is " + typeCombo.getText() + " " + "\""
 211                                 + NameUtil.getDisplayName(relatedName) + "\"";
 212
 213                 btnFromRelatedToBase.setText(strDirection1);
 214                 btnFromBaseToRelated.setText(strDirection2);
 215         }
 216
 217         @Override
 218         public boolean canFlipToNextPage() {
 219                 return isPageComplete();
 220         }
 221
 222     public boolean isPageComplete() {
 223         return (nameSelected && typeSelected && directionSelected);
 224     }
 225
 226         private void updatePage() {
 227                 if (nameSelected) {
 228                         enableType(true);
 229                         if (typeSelected) {
 230                                 enableDirection(true);
 231                         } else {
 232                                 enableDirection(false);
 233                         }
 234                 } else {
 235                         enableType(false);
 236                         enableDirection(false);
 237                 }
 238                 getWizard().getContainer().updateButtons();
 239         }
 240
 241         private void enableType(boolean enabled) {
 242                 lblType.setEnabled(enabled);
 243                 typeCombo.setEnabled(enabled);
 244         }
 245
 246         private void enableDirection(boolean enabled) {
 247                 if (enabled) {
 248                         setDirectionLabels();
 249                 } else {
 250 //                      directionSelected = false;
 251                 }
 252                 lblDirection.setEnabled(enabled);
 253                 btnFromRelatedToBase.setEnabled(enabled);
 254                 btnFromBaseToRelated.setEnabled(enabled);
 255
 256                 btnFromRelatedToBase.setVisible(enabled);
 257                 btnFromBaseToRelated.setVisible(enabled);
 258
 259         }
 260
 261         /* (non-Javadoc)
 262          * @see org.eclipse.jface.wizard.WizardPage#setPageComplete(boolean)
 263          */
 264         public void setPageComplete(boolean complete) {
 265         super.setPageComplete(complete);
 266
 267         // Add a new relation to the list
 268         if (complete) {
 269                 NameRelationship relation = new TemporaryNameRelationship(
 270                                 toName, fromName, type, referenceComposite.getReference(),
 271                                 referenceComposite.getMicroReference(), null);
 272                 nameRelationsList.add(relation);
 273         }
 274         }
 275
 276         public class TemporaryNameRelationship extends NameRelationship {
 277
 278                 /**
 279                  *
 280                  */
 281                 private static final long serialVersionUID = 1231912353305134080L;
 282
 283                 /**
 284                  * @param toName
 285                  * @param fromName
 286                  * @param type
 287                  * @param citation
 288                  * @param citationMicroReference
 289                  * @param ruleConsidered
 290                  */
 291                 protected TemporaryNameRelationship(TaxonNameBase<?, ?> toName,
 292                                 TaxonNameBase<?, ?> fromName, NameRelationshipType type,
 293                                 ReferenceBase<?> citation, String citationMicroReference,
 294                                 String ruleConsidered) {
 295                         super(toName, fromName, type, citation, citationMicroReference, ruleConsidered);
 296                 }
 297         }
 298 }