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