eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/wizard/AvailableDistributionPage.java

   1 /**
   2  * Copyright (C) 2014 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 package eu.etaxonomy.taxeditor.preference.wizard;
  10
  11 import java.util.ArrayList;
  12 import java.util.Arrays;
  13 import java.util.Collection;
  14 import java.util.HashMap;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Set;
  18 import java.util.UUID;
  19
  20 import org.eclipse.jface.preference.IPreferenceStore;
  21 import org.eclipse.jface.viewers.CheckStateChangedEvent;
  22 import org.eclipse.jface.viewers.CheckboxTreeViewer;
  23 import org.eclipse.jface.viewers.ICheckStateListener;
  24 import org.eclipse.jface.viewers.ITreeSelection;
  25 import org.eclipse.jface.viewers.StyledString.Styler;
  26 import org.eclipse.jface.viewers.TreePath;
  27 import org.eclipse.jface.wizard.WizardPage;
  28 import org.eclipse.swt.SWT;
  29 import org.eclipse.swt.graphics.TextStyle;
  30 import org.eclipse.swt.layout.GridData;
  31 import org.eclipse.swt.layout.GridLayout;
  32 import org.eclipse.swt.widgets.Composite;
  33 import org.eclipse.swt.widgets.Display;
  34
  35 import eu.etaxonomy.cdm.api.service.ITermService;
  36 import eu.etaxonomy.cdm.api.service.IVocabularyService;
  37 import eu.etaxonomy.cdm.model.common.CdmBase;
  38 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  39 import eu.etaxonomy.cdm.model.common.TermType;
  40 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  41 import eu.etaxonomy.taxeditor.editor.definedterm.TermContentProvider;
  42 import eu.etaxonomy.taxeditor.editor.definedterm.TermLabelProvider;
  43 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
  44 import eu.etaxonomy.taxeditor.session.ICdmEntitySession;
  45 import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
  46 import eu.etaxonomy.taxeditor.store.CdmStore;
  47
  48 /**
  49  * @author a.oppermann
  50  * @date 21.07.2014
  51  *
  52  */
  53 public class AvailableDistributionPage extends WizardPage implements ICdmEntitySessionEnabled {
  54
  55     private CheckboxTreeViewer viewer;
  56
  57     private Set<TermVocabulary<DefinedTermBase>> vocabularies;
  58
  59     /**
  60      * @param pageName
  61      */
  62     protected AvailableDistributionPage(String pageName) {
  63         super(pageName);
  64         // TODO check if configuration exists
  65         CdmStore.getCurrentSessionManager().bindNullSession();
  66     }
  67
  68     /*
  69      * (non-Javadoc)
  70      *
  71      * @see
  72      * org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets
  73      * .Composite)
  74      */
  75     /** {@inheritDoc} */
  76     @Override
  77     public void createControl(Composite parent) {
  78         IPreferenceStore preferenceStore = PreferencesUtil.getPreferenceStore();
  79         String checkedValues = preferenceStore.getString(PreferencesUtil.DISTRIBUTION_AREA_OCCURENCE_STATUS);
  80         String grayedValues = preferenceStore.getString(PreferencesUtil.DISTRIBUTION_AREA_OCCURENCE_STATUS_GRAYED);
  81         setTitle("Select areas for Distribution Editor");
  82         setDescription("In order to be able to modify and see the distribution status of taxa,\n"
  83                 + "you have to select the areas which you like to see.");
  84         Composite composite = new Composite(parent, SWT.NULL);
  85         composite.setLayout(new GridLayout());
  86         viewer = new CheckboxTreeViewer(composite, SWT.NULL);
  87         viewer.getTree().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
  88         viewer.setContentProvider(new TermContentProvider());
  89         Styler styler = new Styler() {
  90             @Override
  91             public void applyStyles(TextStyle textStyle) {
  92                 textStyle.foreground = Display.getCurrent().getSystemColor(SWT.COLOR_BLACK);
  93             }
  94         };
  95         viewer.setLabelProvider(new TermLabelProvider(styler));
  96         viewer.addCheckStateListener(new ICheckStateListener() {
  97
  98             private boolean ignoreCheckEvent = false;
  99
 100             @Override
 101             public void checkStateChanged(CheckStateChangedEvent event) {
 102
 103
 104                 if (ignoreCheckEvent ) {
 105                     return;
 106                 }
 107
 108                 ignoreCheckEvent = true;
 109
 110                 try {
 111                     TreePath path  = ((ITreeSelection) viewer.getSelection()).getPaths()[0];
 112                     checkChildren(event.getElement(), event.getChecked());
 113                     checkParents(path.getParentPath());
 114                 }
 115                 finally {
 116                     ignoreCheckEvent = false;
 117                 }
 118                 checkNoneChecked();
 119             }
 120         });
 121         // TODO: write listener or toggle button to select all named areas
 122
 123         rememberCheckedValues(checkedValues, grayedValues);
 124         setControl(composite);
 125     }
 126
 127
 128     protected List<TermVocabulary<DefinedTermBase>> initialiseVocabularies() {
 129         if (vocabularies != null) {
 130             vocabularies.clear();
 131         }
 132         List<TermVocabulary<DefinedTermBase>> vocs = CdmStore.getService(IVocabularyService.class).findByTermType(
 133                 TermType.NamedArea);
 134         return vocs;
 135     }
 136
 137     private void rememberCheckedValues(String checkedValues, String grayedValues) {
 138         viewer.setInput(initialiseVocabularies());
 139
 140         if (grayedValues != null && grayedValues != "") {
 141             String[] listGrayed = grayedValues.split(",");
 142             ArrayList listGrayedTerms = new ArrayList();
 143             getTermsFromStringValues(listGrayed, listGrayedTerms);
 144             for(Object element : listGrayedTerms){
 145                 if(element != null){
 146                     viewer.setGrayChecked(element, true);
 147                 }
 148             }
 149         }
 150         if (checkedValues != null && checkedValues != "") {
 151             String[] listChecked = checkedValues.split(",");
 152             ArrayList<DefinedTermBase<?>> listCheckedTerms = new ArrayList<DefinedTermBase<?>>();
 153             getTermsFromStringValues(listChecked, listCheckedTerms);
 154             for(Object element : listCheckedTerms){
 155                 if(element != null){
 156                     viewer.setChecked(element, true);
 157                 }
 158             }
 159         }
 160     }
 161
 162     /**
 163      * @param split
 164      * @param termlist
 165      */
 166     private void getTermsFromStringValues(String[] split, ArrayList termlist) {
 167         List<String> listValue = Arrays.asList(split);
 168         for (String s : listValue) {
 169             UUID uuid = UUID.fromString(s);
 170             ITermService termService = CdmStore.getService(ITermService.class);
 171             DefinedTermBase definedTermBase = termService.load(uuid);
 172             if(definedTermBase != null){
 173                 termlist.add(definedTermBase);
 174             }else{
 175                 IVocabularyService vocabularyService = CdmStore.getService(IVocabularyService.class);
 176                 TermVocabulary termVocabulary = vocabularyService.load(uuid);
 177                 termlist.add(termVocabulary);
 178             }
 179         }
 180     }
 181
 182     private boolean checkNoneChecked() {
 183
 184         if (viewer.getCheckedElements().length == 0) {
 185             setMessage("Please check at least one item", WARNING);
 186             return true;
 187         } else {
 188             setMessage(null);
 189             return false;
 190         }
 191     }
 192
 193     /**
 194      * @return the viewer
 195      */
 196     public CheckboxTreeViewer getViewer() {
 197         return viewer;
 198     }
 199
 200     /**
 201      *
 202      * @param path
 203      */
 204     private void checkParents(final TreePath path) {
 205         if (path == null) {
 206             return;
 207         }
 208         TermContentProvider tcp = new TermContentProvider();
 209         Object treeElement = path.getLastSegment();
 210
 211         if (treeElement != null) {
 212             boolean allChecked = true;
 213             boolean allUnchecked = true;
 214             for (final Object fieldElement : tcp.getChildren(treeElement)) {
 215                 allChecked = allChecked && this.viewer.getChecked(fieldElement);
 216                 allUnchecked = allUnchecked && !this.viewer.getChecked(fieldElement);
 217             }
 218             if (allUnchecked) {
 219                 this.viewer.setChecked(treeElement, false);
 220                 this.viewer.setGrayed(treeElement, false);
 221             } else if (allChecked) {
 222                 this.viewer.setChecked(treeElement, true);
 223                 this.viewer.setGrayed(treeElement, false);
 224             } else if (!allUnchecked && !allChecked) {
 225                 this.viewer.setChecked(treeElement, true);
 226                 this.viewer.setGrayed(treeElement, true);
 227             }
 228         }
 229         checkParents(path.getParentPath());
 230     }
 231
 232 //    /**
 233 //     *
 234 //     * @param path
 235 //     * @param checked
 236 //     */
 237 //    private void checkChildren(final TreePath path, final boolean checked) {
 238 //        TermContentProvider tcp = new TermContentProvider();
 239 //
 240 //        if (path == null) {
 241 //            return;
 242 //        }
 243 //        final Object element = path.getLastSegment();
 244 //        if (element != null) {
 245 //            this.viewer.setChecked(element, checked);
 246 //            this.viewer.setGrayed(element, false);
 247 //            int length = tcp.getChildren(element).length;
 248 //            if(length>1){
 249 //                this.viewer.expandToLevel(element, CheckboxTreeViewer.ALL_LEVELS);
 250 //                this.viewer.setSubtreeChecked(element, checked);
 251 //            }
 252 //        }
 253 //    }
 254
 255     /**
 256     *
 257     * @param path
 258     * @param checked
 259     */
 260    private void checkChildren(final Object element, final boolean checked) {
 261        TermContentProvider tcp = new TermContentProvider();
 262
 263        if (element == null) {
 264            return;
 265        }
 266     //   final Object element = path.getLastSegment();
 267        if (element != null) {
 268            this.viewer.setChecked(element, checked);
 269            this.viewer.setGrayed(element, false);
 270            int length = tcp.getChildren(element).length;
 271            if(length>1){
 272                this.viewer.expandToLevel(element, CheckboxTreeViewer.ALL_LEVELS);
 273                this.viewer.setSubtreeChecked(element, checked);
 274            }
 275        }
 276    }
 277
 278     @Override
 279     public void dispose() {
 280         CdmStore.getCurrentSessionManager().dispose(this);
 281         super.dispose();
 282     }
 283     /* (non-Javadoc)
 284      * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled#getCdmEntitySession()
 285      */
 286     @Override
 287     public ICdmEntitySession getCdmEntitySession() {
 288         return CdmStore.getCurrentSessionManager().getNullSession();
 289     }
 290
 291     /* (non-Javadoc)
 292      * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled#getRootEntities()
 293      */
 294     @Override
 295     public <T extends CdmBase> Collection<T> getRootEntities() {
 296         return null;
 297     }
 298
 299     /* (non-Javadoc)
 300      * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled#getPropertyPathsMap()
 301      */
 302     @Override
 303     public Map<Object, List<String>> getPropertyPathsMap() {
 304         Map<Object, List<String>> propertyPathsMap = new HashMap<Object, List<String>>();
 305         List<String> termsPropertyPaths = Arrays.asList(new String[] {
 306                 "includes"
 307         });
 308         propertyPathsMap.put("includes", termsPropertyPaths);
 309         propertyPathsMap.put("terms", termsPropertyPaths);
 310         return propertyPathsMap;
 311     }
 312
 313 }