eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/menu/AbstractMenuPreferences.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.preference.menu;
  11
  12 import java.util.ArrayList;
  13 import java.util.HashMap;
  14 import java.util.List;
  15
  16 import org.eclipse.core.commands.Command;
  17 import org.eclipse.core.commands.IParameter;
  18 import org.eclipse.core.commands.Parameterization;
  19 import org.eclipse.core.commands.ParameterizedCommand;
  20 import org.eclipse.core.commands.common.NotDefinedException;
  21 import org.eclipse.core.runtime.IStatus;
  22 import org.eclipse.jface.viewers.CheckStateChangedEvent;
  23 import org.eclipse.jface.viewers.CheckboxTableViewer;
  24 import org.eclipse.jface.viewers.ICheckStateListener;
  25 import org.eclipse.jface.wizard.WizardDialog;
  26 import org.eclipse.swt.SWT;
  27 import org.eclipse.swt.events.SelectionAdapter;
  28 import org.eclipse.swt.events.SelectionEvent;
  29 import org.eclipse.swt.layout.GridData;
  30 import org.eclipse.swt.layout.GridLayout;
  31 import org.eclipse.swt.widgets.Button;
  32 import org.eclipse.swt.widgets.Composite;
  33 import org.eclipse.swt.widgets.Control;
  34 import org.eclipse.ui.IWorkbench;
  35 import org.eclipse.ui.IWorkbenchPreferencePage;
  36 import org.eclipse.ui.commands.ICommandService;
  37 import org.eclipse.ui.handlers.IHandlerService;
  38
  39 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
  40 import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
  41 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  42 import eu.etaxonomy.cdm.model.common.TermType;
  43 import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
  44 import eu.etaxonomy.taxeditor.editor.definedterm.DefinedTermEditor;
  45 import eu.etaxonomy.taxeditor.model.AbstractUtility;
  46 import eu.etaxonomy.taxeditor.model.MessagingUtils;
  47 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
  48 import eu.etaxonomy.taxeditor.preference.wizard.VocabularyTermWizard;
  49 import eu.etaxonomy.taxeditor.store.CdmStore;
  50 import eu.etaxonomy.taxeditor.store.TermStore;
  51
  52 /**
  53  * @author n.hoffmann
  54  * @created 12.06.2009
  55  * @version 1.0
  56  */
  57 public abstract class AbstractMenuPreferences<T extends DefinedTermBase> extends CdmPreferencePage implements
  58                 IWorkbenchPreferencePage, IConversationEnabled{
  59
  60         private Button toggleButton;
  61         protected HashMap<DefinedTermBase<T>, Button> menuButtons;
  62
  63         protected Button newButton;
  64         protected Button editButton;
  65         protected Button removeButton;
  66
  67         protected CheckboxTableViewer tableViewer;
  68
  69         private boolean state = true;
  70         private final boolean vocabularyIsEditable;
  71         private ConversationHolder conversation;
  72
  73         /**
  74          * Constructs a new menu preference page.
  75          *
  76          * @param initialVocabulary
  77          *                      the initial vocabulary containing all possible entries for the menu
  78          * @param title
  79          *                      the title of the page
  80          * @param description
  81          *                      describing text for the preference page
  82          * @param editable
  83          *                      whether this vocabulary should be editable. Will render "New", "Edit", "Delete" buttons
  84          *                      Handler for these buttons have to be overriding addEditButtonListeners()
  85          * @param <T> a T object.
  86          */
  87         public AbstractMenuPreferences(String title, String description, boolean editable) {
  88                 super(title);
  89                 vocabularyIsEditable = editable;
  90                 setDescription(description);
  91         }
  92
  93         protected List<T> getTerms(){
  94             if(!CdmStore.isActive() || getTermClass()==null) {
  95                 return new ArrayList<T>();
  96             } else {
  97                 return TermStore.getTerms(getTermClass());
  98             }
  99         }
 100
 101         /**
 102          * {@inheritDoc}
 103          *
 104          * Create contents of the preference page
 105          */
 106         @Override
 107         public Control createContents(Composite parent) {
 108
 109                 Composite container = new Composite(parent, SWT.NULL);
 110                 final GridLayout gridLayout = new GridLayout();
 111                 gridLayout.numColumns = 2;
 112                 container.setLayout(gridLayout);
 113
 114                 tableViewer = CheckboxTableViewer.newCheckList(container, SWT.NULL);
 115                 GridData tableLayoutData = new GridData(SWT.FILL, SWT.FILL, true, false);
 116                 tableLayoutData.heightHint = 300;
 117                 tableViewer.getTable().setLayoutData(tableLayoutData);
 118
 119                 tableViewer.setContentProvider(new DefinedTermBaseContentProvider());
 120                 tableViewer.setLabelProvider(new DefinedTermBaseLabelProvider());
 121
 122                 refresh(getTerms());
 123
 124                 tableViewer.addCheckStateListener(new ICheckStateListener() {
 125
 126                         @Override
 127                         public void checkStateChanged(CheckStateChangedEvent arg0) {
 128                                 checkNoneChecked();
 129                         }
 130                 });
 131
 132                 Composite buttonContainer = new Composite(container, SWT.NULL);
 133                 GridData buttonContainerLayoutData = new GridData();
 134                 buttonContainerLayoutData.verticalAlignment = SWT.TOP;
 135                 buttonContainer.setLayoutData(buttonContainerLayoutData);
 136                 buttonContainer.setLayout(new GridLayout());
 137
 138                 if(vocabularyIsEditable) {
 139             createEditButtons(buttonContainer);
 140         }
 141
 142                 toggleButton = new Button(buttonContainer, SWT.PUSH);
 143                 toggleButton.setText("Toggle");
 144                 toggleButton.addSelectionListener(new SelectionAdapter(){
 145                         @Override
 146                         public void widgetSelected(SelectionEvent e) {
 147                                 state = state ? false : true;
 148                                 tableViewer.setAllChecked(state);
 149                                 checkNoneChecked();
 150                         }
 151                 });
 152
 153                 createAdditionalContent(container);
 154
 155                 return container;
 156         }
 157
 158         protected void refresh(List<T> definedTerms) {
 159                 tableViewer.setInput(definedTerms);
 160
 161                 List<T> preferedTerms = CdmStore.getTermManager().getFilteredTerms(definedTerms);
 162                 tableViewer.setCheckedElements(preferedTerms.toArray());
 163         }
 164
 165         protected void createAdditionalContent(Composite container) {
 166                 // implement where needed
 167         }
 168
 169         protected void createEditButtons(Composite buttonContainer) {
 170
 171                 editButton = new Button(buttonContainer, SWT.PUSH);
 172                 editButton.setText("Open Term Editor");
 173                 editButton.setLayoutData(new GridData(SWT.FILL));
 174
 175                 addEditButtonListeners();
 176         }
 177
 178         /**
 179          * Implement this method in MenuPreference Pages where the vocabulary should be editable, editable flag
 180          * is set.
 181          */
 182         protected void addNewButtonListeners() {
 183                 newButton.addSelectionListener(new SelectionAdapter(){
 184                         @Override
 185                         public void widgetSelected(SelectionEvent e) {
 186                                 VocabularyTermWizard<T> wizard = new VocabularyTermWizard<T>(getTermClass(), getConversationHolder());
 187
 188                                 WizardDialog dialog = new WizardDialog(AbstractUtility.getShell(), wizard);
 189                             if(dialog.open() == IStatus.OK){
 190                                 tableViewer.setInput(getTerms());
 191                             }
 192                         }
 193
 194                 });
 195         }
 196
 197         /**
 198          * Implement this method in MenuPreference Pages where the vocabulary should be editable, editable flag
 199          * is set.
 200          */
 201         protected void addEditButtonListeners() {
 202                 editButton.addSelectionListener(new SelectionAdapter(){
 203                         @Override
 204                         public void widgetSelected(SelectionEvent event) {
 205
 206                                 ICommandService commandService = (ICommandService)  AbstractUtility.getService(ICommandService.class);
 207
 208                                 Command command = commandService.getCommand(DefinedTermEditor.OPEN_COMMAND_ID);
 209
 210                                 IParameter parameter;
 211                                 try {
 212                                         parameter = command.getParameter("eu.etaxonomy.taxeditor.store.openDefinedTermEditor.termTypeUuid");
 213
 214                                         Parameterization[] parameterizations = new Parameterization[]{
 215                                                         new Parameterization(parameter, TermType.valueOf(getTermClass().getSimpleName()).getUuid().toString())
 216                                         };
 217
 218                                         ParameterizedCommand pCommand = new ParameterizedCommand(command, parameterizations);
 219
 220                                         if (command.isEnabled()) {
 221                                                 IHandlerService handlerService = (IHandlerService) AbstractUtility.getService(IHandlerService.class);
 222                                                 try {
 223                                                         handlerService.executeCommand(pCommand, null);
 224                                                 } catch (NotDefinedException e) {
 225                                                         throw new RuntimeException("Could not find open command: "
 226                                                                         + DefinedTermEditor.OPEN_COMMAND_ID);
 227                                                 } catch (Exception e) {
 228                                                         MessagingUtils
 229                                                                         .error(getClass(),
 230                                                                                         "An exception occured while trying to open a selection",
 231                                                                                         e);
 232                                                 }
 233                                         }
 234                                 } catch (NotDefinedException e) {
 235                                         MessagingUtils
 236                                         .error(getClass(),
 237                                                         "An exception occured while trying to open the Term Editor",
 238                                                         e);
 239                                 }
 240
 241                         }
 242                 });
 243         }
 244
 245         /** {@inheritDoc} */
 246         @Override
 247     public void init(IWorkbench workbench) {
 248             setPreferenceStore(PreferencesUtil.getPreferenceStore());
 249             if(!CdmStore.isActive()) {
 250                 MessagingUtils.noDataSourceWarningDialog(null);
 251
 252             } else {
 253                 getConversationHolder().bind();
 254             }
 255         }
 256
 257         /**
 258          * <p>performDefaults</p>
 259          */
 260         @Override
 261     protected void performDefaults() {
 262                 tableViewer.setAllChecked(true);
 263         }
 264
 265         public CheckboxTableViewer getTableViewer() {
 266                 return tableViewer;
 267         }
 268
 269         /** {@inheritDoc} */
 270         @Override
 271         public boolean performOk() {
 272             if(!CdmStore.isActive()) {
 273                 return true;
 274             }
 275
 276                 if(checkNoneChecked()){
 277                         return false;
 278                 }
 279
 280                 getConversationHolder().commit(true);
 281
 282                 List<T> preferredTerms = new ArrayList<T>();
 283                 for (Object element : getTableViewer().getCheckedElements()){
 284                         preferredTerms.add((T) element);
 285                 }
 286
 287                 CdmStore.getTermManager().setPreferredTerms(preferredTerms, getTerms());
 288
 289                 refresh(getTerms());
 290
 291                 PreferencesUtil.firePreferencesChanged(this.getClass());
 292
 293
 294                 return super.performOk();
 295         }
 296
 297         private boolean checkNoneChecked(){
 298
 299                 if(tableViewer.getCheckedElements().length == 0){
 300                         setMessage("Please check at least one item", WARNING);
 301                         return true;
 302                 }else{
 303                         setMessage(null);
 304                         return false;
 305                 }
 306         }
 307
 308         protected abstract Class<T> getTermClass();
 309
 310         @Override
 311         public ConversationHolder getConversationHolder() {
 312                 if(conversation == null){
 313                         conversation = CdmStore.createConversation();
 314                 }
 315                 return conversation;
 316         }
 317
 318         @Override
 319         public void update(CdmDataChangeMap changeEvents) {
 320                 // implement where needed
 321         }
 322 }