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