eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/menu/AbstractMenuPreferences.java

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