EDIT

/**

 * Copyright (C) 2007 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.preference.menu;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import org.eclipse.core.commands.Command;

import org.eclipse.core.commands.IParameter;

import org.eclipse.core.commands.Parameterization;

import org.eclipse.core.commands.ParameterizedCommand;

import org.eclipse.core.commands.common.NotDefinedException;

import org.eclipse.jface.viewers.CheckStateChangedEvent;

import org.eclipse.jface.viewers.CheckboxTableViewer;

import org.eclipse.jface.viewers.ICheckStateListener;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.ui.commands.ICommandService;

import org.eclipse.ui.handlers.IHandlerService;

import eu.etaxonomy.cdm.model.term.DefinedTermBase;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.taxeditor.editor.definedterm.e4.DefinedTermEditorE4;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.TermStore;

/**

 * @author n.hoffmann

 * @created 12.06.2009

 * @version 1.0

 */

public abstract class AbstractMenuPreferences<T extends DefinedTermBase> extends CdmPreferencePage {

	private Button toggleButton;

	protected HashMap<DefinedTermBase<T>, Button> menuButtons;

	protected Button editButton;

	protected Button removeButton;

	protected CheckboxTableViewer tableViewer;

	private boolean state = true;

	private final boolean vocabularyIsEditable;

	/**

	 * Constructs a new menu preference page.

	 *

	 * @param initialVocabulary

	 * 			the initial vocabulary containing all possible entries for the menu

	 * @param title

	 * 			the title of the page

	 * @param description

	 * 			describing text for the preference page

	 * @param editable

	 * 			whether this vocabulary should be editable. Will render "New", "Edit", "Delete" buttons

	 * 			Handler for these buttons have to be overriding addEditButtonListeners()

	 * @param <T> a T object.

	 */

	public AbstractMenuPreferences(String title, String description, boolean editable) {

		super(title);

		vocabularyIsEditable = editable;

		setDescription(description);

		init();

	}

	protected List<T> getTerms(){

	    if(CdmStore.isActive() && getTermType()!=null){

	        return TermStore.getTerms(getTermType(), null);

	    }

	    return new ArrayList<T>();

	}

	/**

	 * {@inheritDoc}

	 *

	 * Create contents of the preference page

	 */

	@Override

	public Control createContents(Composite parent) {

		Composite container = new Composite(parent, SWT.NULL);

		final GridLayout gridLayout = new GridLayout();

		gridLayout.numColumns = 2;

		container.setLayout(gridLayout);

		tableViewer = CheckboxTableViewer.newCheckList(container, SWT.NULL);

		GridData tableLayoutData = new GridData(SWT.FILL, SWT.FILL, true, false);

		tableLayoutData.heightHint = 300;

		tableViewer.getTable().setLayoutData(tableLayoutData);

		tableViewer.setContentProvider(new DefinedTermBaseContentProvider());

		tableViewer.setLabelProvider(new DefinedTermBaseLabelProvider());

		refresh(getTerms());

		tableViewer.addCheckStateListener(new ICheckStateListener() {

			@Override

			public void checkStateChanged(CheckStateChangedEvent arg0) {

				checkNoneChecked();

				setApply(true);

			}

		});

		Composite buttonContainer = new Composite(container, SWT.NULL);

		GridData buttonContainerLayoutData = new GridData();

		buttonContainerLayoutData.verticalAlignment = SWT.TOP;

		buttonContainer.setLayoutData(buttonContainerLayoutData);

		buttonContainer.setLayout(new GridLayout());

		if(vocabularyIsEditable) {

            createEditButtons(buttonContainer);

        }

		toggleButton = new Button(buttonContainer, SWT.PUSH);

		toggleButton.setText("Toggle");

		toggleButton.addSelectionListener(new SelectionAdapter(){

			@Override

			public void widgetSelected(SelectionEvent e) {

				state = state ? false : true;

				tableViewer.setAllChecked(state);

				checkNoneChecked();

				setApply(true);

			}

		});

		createAdditionalContent(container);

		return container;

	}

	protected void refresh(List<T> definedTerms) {

		tableViewer.setInput(definedTerms);

		List<T> preferedTerms = CdmStore.getTermManager().getFilteredTerms(definedTerms);

		tableViewer.setCheckedElements(preferedTerms.toArray());

	}

	protected void createAdditionalContent(Composite container) {

		// implement where needed

	}

	protected void createEditButtons(Composite buttonContainer) {

		editButton = new Button(buttonContainer, SWT.PUSH);

		editButton.setText("Open Term Editor");

		editButton.setLayoutData(new GridData(SWT.FILL));

		addEditButtonListeners();

	}

	/**

	 * Implement this method in MenuPreference Pages where the vocabulary should be editable, editable flag

	 * is set.

	 */

	protected void addEditButtonListeners() {

		editButton.addSelectionListener(new SelectionAdapter(){

			@Override

			public void widgetSelected(SelectionEvent event) {

			    setApply(true);

				ICommandService commandService = (ICommandService)  AbstractUtility.getService(ICommandService.class);

				Command command = commandService.getCommand(DefinedTermEditorE4.OPEN_COMMAND_ID);

				IParameter parameter;

				try {

					parameter = command.getParameter("eu.etaxonomy.taxeditor.store.openDefinedTermEditor.termTypeUuid");

					Parameterization[] parameterizations = new Parameterization[]{

							new Parameterization(parameter, getTermType().getUuid().toString())

					};

					ParameterizedCommand pCommand = new ParameterizedCommand(command, parameterizations);

					if (command.isEnabled()) {

						IHandlerService handlerService = (IHandlerService) AbstractUtility.getService(IHandlerService.class);

						try {

							handlerService.executeCommand(pCommand, null);

						} catch (NotDefinedException e) {

							throw new RuntimeException("Could not find open command: "

									+ DefinedTermEditorE4.OPEN_COMMAND_ID);

						} catch (Exception e) {

							MessagingUtils

									.error(getClass(),

											"An exception occurred while trying to open a selection",

											e);

						}

					}

				} catch (NotDefinedException e) {

					MessagingUtils

					.error(getClass(),

							"An exception occurred while trying to open the Term Editor",

							e);

				}

			}

		});

	}

	/** {@inheritDoc} */

	@Override

    public void init() {

	    setPreferenceStore(PreferencesUtil.getPreferenceStore());

	}

	/**

	 * <p>performDefaults</p>

	 */

	@Override

    protected void performDefaults() {

		tableViewer.setAllChecked(true);

		setApply(true);

	}

	/** {@inheritDoc} */

	@Override

	public boolean performOk() {

	    if(!CdmStore.isActive()) {

	        return true;

	    }

		if(checkNoneChecked()){

			return false;

		}

		if(tableViewer!=null){

		    List<T> preferredTerms = new ArrayList<T>();

		    for (Object element : tableViewer.getCheckedElements()){

		        preferredTerms.add((T) element);

		    }

		    CdmStore.getTermManager().setPreferredTerms(preferredTerms, getTerms());

		    CdmStore.getTermManager().clearTermMapForTermType(getTermType());

		    refresh(getTerms());

		    PreferencesUtil.firePreferencesChanged(this.getClass());

		}

		return super.performOk();

	}

	protected boolean checkNoneChecked(){

		if(tableViewer!=null && tableViewer.getCheckedElements().length == 0){

			setMessage("Please check at least one item", WARNING);

			return true;

		}else{

			setMessage(null);

			return false;

		}

	}

	protected abstract TermType getTermType();

}