EDIT

/**

 *

 */

package eu.etaxonomy.taxeditor.ui.combo;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import org.eclipse.jface.fieldassist.ComboContentAdapter;

import org.eclipse.jface.fieldassist.ContentProposalAdapter;

import org.eclipse.jface.fieldassist.IContentProposal;

import org.eclipse.jface.fieldassist.IContentProposalListener;

import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.widgets.Listener;

import eu.etaxonomy.cdm.api.service.IVocabularyService;

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

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

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

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.TermManager;

import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;

import eu.etaxonomy.taxeditor.ui.element.CdmPropertyChangeEvent;

import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;

/**

 * @author n.hoffmann

 * @created Nov 5, 2009

 * @version 1.0

 * @param <VOC>

 */

public class VocabularyComboElement<TERM extends DefinedTermBase<TERM>, VOC extends TermVocabulary<TERM>>

		extends AbstractComboElement<VOC> {

	private VOC emptyElement;

	private static String EMPTY_ELEMENT_LABEL = "";

	private ArrayList<VOC> terms;

	private Comparator<VOC> vocComparator;

    private final TermType termType;

	public VocabularyComboElement(CdmFormFactory formFactory,

	        ICdmFormElement parentElement, TermType termType, String labelString, VOC selection,

	        int style) {

        super(formFactory, parentElement);

        this.termType = termType;

        populateTerms(getVocabularies());

        combo.addSelectionListener(this);

        combo.addDisposeListener(this);

        ContentProposalAdapter adapter;

        adapter = new ContentProposalAdapter(combo, new ComboContentAdapter(), getProposalProvider(), null, null);

        adapter.setPropagateKeys(true);

        adapter.setProposalAcceptanceStyle(ContentProposalAdapter.PROPOSAL_REPLACE);

        adapter.addContentProposalListener(new IContentProposalListener() {

            @Override

            public void proposalAccepted(IContentProposal proposal) {

                setSelection((VOC)combo.getData(proposal.getContent()));

                firePropertyChangeEvent(new CdmPropertyChangeEvent(getComboElement(), null));

            }

        });

        PreferencesUtil.getPreferenceStore().addPropertyChangeListener(this);

        if (selection != null) {

            setSelection(selection);

        }

	}

	/**

	 * <p>Sets the selection of the combo to the given T object.</p>

	 * <p>Passing <code>null</code> to this method will set the selection to

	 * the empty element and effectively clear the selection</p>

	 *

	 * @param selection

	 *            a T object or <code>null</code> to clear the selection

	 */

	@Override

    public void setSelection(VOC selection) {

		this.selection = selection;

		this.selection = selection;

		Listener[] listeners = combo.getListeners(SWT.Selection);

//		for (Listener listener : listeners) {

//			combo.removeListener(SWT.Selection, listener);

//		}

		int selectedIndex;

		if(selection == null){

			// set selection to the emptyElement

			selectedIndex = 0;

		}else{

			selectedIndex = terms.indexOf(selection);

			if (selectedIndex == -1) {

				createTermNotInPreferredTerms(selection);

				selectedIndex = terms.indexOf(selection);

			}

		}

		combo.select(selectedIndex);

//		for (Listener listener : listeners) {

//			combo.addListener(SWT.Selection, listener);

//		}

	}

	/**

	 * Fills the combo with elements and sets up the convenience functions

	 * for selection index

	 *

	 * @param preferredTerms

	 */

	private void populateTerms(List<VOC> preferredTerms) {

		combo.removeAll();

		terms = new ArrayList<VOC>();

		int i = 1;

		int index = 0;

		// Add an empty element for when nothing was selected yet

		combo.add(EMPTY_ELEMENT_LABEL);

		terms.add(emptyElement);

		if (vocComparator != null) {

			Collections.sort(preferredTerms, vocComparator);

		}else{

		    Collections.sort(preferredTerms, new Comparator<VOC>() {

                @Override

                public int compare(VOC o1, VOC o2) {

                    if (o1.equals(o2)){

                        return 0;

                    }

                    int result = ((TermVocabulary) o1).getTitleCache().compareTo(((TermVocabulary)o2).getTitleCache());

                    return result;

                }

            });

		}

		for (VOC term : preferredTerms) {

			String label = getLabel(term);

			if (label == null) {

				if (term.getTitleCache() != null) {

					label = term.getTitleCache();

					MessagingUtils.warn(getClass(),

							"Term does not have a default language representation: " + label

									+ ", " + term.getUuid());

				} else {

					label = "Unknown";

					MessagingUtils.warn(getClass(),

							"Representation Label and TitleCache empty for term: "

									+ term + ", " + term.getUuid());

				}

			}

			combo.add(label);

			combo.setData(label, term);

			terms.add(term);

			i++;

			if (selection != null) {

				if (selection.equals(term)) {

					index = i;

				}

			}

		}

		if (selection != null && index == 0) {

			createTermNotInPreferredTerms(selection);

		}

		combo.select(index);

	}

	protected List<VOC> getVocabularies(){

	    List<TermVocabulary<TERM>> list = CdmStore.getService(IVocabularyService.class).<TERM>findByTermType(termType, null);

		return (List<VOC>) list;

	}

	/**

	 * May be overridden by derived classes if the desired label string does not

	 * reside in term.getLabel();

	 *

	 * @param term

	 *            a T object.

	 * @return a {@link java.lang.String} object.

	 */

	protected String getLabel(VOC term) {

		if (term == null){

			return "";

		}else{

			return term.getLabel(CdmStore.getDefaultLanguage());

		}

	}

	private void createTermNotInPreferredTerms(VOC term) {

		List<VOC> preferredTerms = getVocabularies();

		preferredTerms.add(term);

		populateTerms(preferredTerms);

	}

	/** {@inheritDoc} */

	@Override

    public void widgetSelected(SelectionEvent e) {

	    int i = combo.getSelectionIndex();

	    if (i > -1){

	        selection = terms.get(i);

	    }else{

	        selection = null;

	    }

		firePropertyChangeEvent(new CdmPropertyChangeEvent(this, e));

	}

	/** {@inheritDoc} */

	@Override

    public void propertyChange(PropertyChangeEvent event) {

		super.propertyChange(event);

		if (event != null

				&& PreferencesUtil.PREFERRED_TERMS_CHANGE.equals(event

						.getProperty())) {

			populateTerms(getVocabularies());

		}

	}

	protected TermManager getTermManager() {

		return CdmStore.getTermManager();

	}

	public int getVisibleItemCount(){

		return combo.getVisibleItemCount();

	}

    public void removeEmptyElement(){

        terms.remove(emptyElement);

        combo.remove(EMPTY_ELEMENT_LABEL);

    }

    private VocabularyComboElement<TERM, VOC> getComboElement(){

        return this;

    }

}