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.editor.view.checklist.e4;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.SortedSet;

import java.util.UUID;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import org.apache.log4j.Logger;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.e4.ui.di.Focus;

import org.eclipse.e4.ui.di.Persist;

import org.eclipse.e4.ui.model.application.ui.MDirtyable;

import org.eclipse.e4.ui.model.application.ui.basic.MPart;

import org.eclipse.e4.ui.workbench.modeling.ESelectionService;

import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;

import org.eclipse.jface.viewers.FocusCellOwnerDrawHighlighter;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.StructuredViewer;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TableViewerColumn;

import org.eclipse.jface.viewers.TableViewerEditor;

import org.eclipse.jface.viewers.TableViewerFocusCellManager;

import org.eclipse.jface.wizard.WizardDialog;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.ModifyListener;

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.Composite;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.MenuItem;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.TableColumn;

import org.eclipse.swt.widgets.Text;

import org.eclipse.swt.widgets.ToolBar;

import org.eclipse.swt.widgets.ToolItem;

import org.eclipse.ui.progress.IWorkbenchSiteProgressService;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;

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

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

import eu.etaxonomy.cdm.model.taxon.Classification;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;

import eu.etaxonomy.taxeditor.editor.EditorUtil;

import eu.etaxonomy.taxeditor.editor.IDistributionEditor;

import eu.etaxonomy.taxeditor.editor.internal.TaxeditorEditorPlugin;

import eu.etaxonomy.taxeditor.editor.l10n.Messages;

import eu.etaxonomy.taxeditor.editor.view.checklist.ChecklistContentProvider;

import eu.etaxonomy.taxeditor.editor.view.checklist.ChecklistEditorComparator;

import eu.etaxonomy.taxeditor.editor.view.checklist.ChecklistEditorInput;

import eu.etaxonomy.taxeditor.editor.view.checklist.ChecklistLabelProvider;

import eu.etaxonomy.taxeditor.editor.view.checklist.filter.ChecklistEditorFilter;

import eu.etaxonomy.taxeditor.editor.view.checklist.listener.ChecklistFocusListener;

import eu.etaxonomy.taxeditor.editor.view.checklist.listener.ChecklistModifyListener;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasFactualData;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.preference.Resources;

import eu.etaxonomy.taxeditor.preference.wizard.AvailableDistributionWizard;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.StoreUtil;

import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;

/**

 *

 * @author k.luther

 *

 */

public class ChecklistEditorE4 implements IPartContentHasFactualData, IConversationEnabled,

       IDirtyMarkable, IPartContentHasDetails, IE4SavablePart, IDistributionEditor{

    private static final String DISTRIBUTION_EDITOR = "Distribution Editor";

	private static final String LOADING_TAXA = Messages.ChecklistEditor_LOAD_TAXA;

    private static final String UNKNOWN = Messages.ChecklistEditor_UNKNOWN;

    private static final String ELEMENT_COUNT = Messages.ChecklistEditor_ELEMENT_COUNT;

    public static final String TYPE_FILTER_TEXT = "type filter text"; //$NON-NLS-1$

    private static final Logger logger = Logger.getLogger(ChecklistEditorE4.class);

    /**

     * Constant

     * <code>ID="eu.etaxonomy.taxeditor.store.datasource"{trunked}</code>

     */

    public static String ID = "eu.etaxonomy.taxeditor.editor.view.checklist.ChecklistEditor"; //$NON-NLS-1$

    private TableViewer viewer;

    private ITaxonNodeService taxonNodeService;

    private ChecklistEditorComparator comparator;

    private ChecklistEditorInput checklistEditorInput;

    private ConversationHolder conversation;

    private Integer countNodes;

    private List<TaxonNode> selectedTaxonNodes;

    @Inject

    private MPart thisPart;

    @Inject

    private MDirtyable dirty;

    @Inject

    private ESelectionService selService;

    private ISelectionChangedListener selectionChangedListener;

    private ChecklistEditorFilter filter;

    private Label statusLabel;

    private ChecklistLabelProvider labelProvider;

//TODO: maybe it is better to use a hashMap for better handling of adding and removing terms??

    private Map<UUID, Integer> areaPosition= new HashMap();

    private ToolItem toolItem;

	private ChecklistDropdownSelectionListenerE4 dropListener;

	private Text searchText;

	public Map<UUID, Integer> getAreaPosition() {

        return areaPosition;

    }

    /**

     * @return the selectedTaxonNodes

     */

    public List<TaxonNode> getSelectedTaxonNodes() {

        return selectedTaxonNodes;

    }

    /**

     * @param selectedTaxonNodes

     *            the selectedTaxonNodes to set

     */

    public void setSelectedTaxonNodes(List<TaxonNode> selectedTaxonNodes) {

        this.selectedTaxonNodes = selectedTaxonNodes;

    }

    @Inject

    public ChecklistEditorE4() {

    }

    /** {@inheritDoc} */

    @PostConstruct

    public void createPartControl(Composite parent) {

    	if (!CdmStore.isActive()){

            return;

        }

        taxonNodeService = CdmStore.getService(ITaxonNodeService.class);

        filter = new ChecklistEditorFilter();

        createTopComposite(parent);

        viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION);

        //the focuzsCellManager should return the distribution!!!

        TableViewerFocusCellManager focusCellManager = new TableViewerFocusCellManager(viewer, new FocusCellOwnerDrawHighlighter (viewer));

        TableViewerEditor.create(viewer, focusCellManager, new ColumnViewerEditorActivationStrategy(viewer), TableViewerEditor.KEYBOARD_ACTIVATION);

//        viewer.addSelectionChangedListener(new ISelectionChangedListener() {

//        	  @Override

//        	  public void selectionChanged(SelectionChangedEvent event) {

//        	    IStructuredSelection selection = viewer.getStructuredSelection();

//        	    Object firstElement = selection.getFirstElement();

//        	    // do something with it

//        	  }

//

//

//        	});

        labelProvider = new ChecklistLabelProvider(this.viewer);

       // SortedSet<DefinedTermBase> termSet = labelProvider.getNamedAreas(true);

//        terms = new HashMap();

//        for (DefinedTermBase term : termSet){

//                terms.put(term.getUuid(), term);

//        }

//        if (terms == null){

//			MessagingUtils.informationDialog(Messages.ChecklistEditor_NO_AREAS, Messages.ChecklistEditor_NO_AREAS_MESSAGE);

//			this.dispose();

//			return;

//		}

        viewer.addFilter(filter);

        createTable();

        viewer.setContentProvider(new ChecklistContentProvider());

        viewer.setLabelProvider(this.labelProvider);

        comparator = new ChecklistEditorComparator();

        viewer.setComparator(comparator);

        final ModifyListener modifyListener = new ChecklistModifyListener(viewer, filter, searchText);

        searchText.addFocusListener(new ChecklistFocusListener(searchText, modifyListener));

        searchText.addModifyListener(modifyListener);

        createGridDataForViewerLayout();

        createStatusBar(parent);

        createToolbar(parent);

    }

    /**

     * @param parent

     */

    private void createTopComposite(Composite parent) {

        GridLayout gridLayout = new GridLayout(3, false);

        gridLayout.marginWidth = 0;

        gridLayout.marginHeight = 0;

        parent.setLayout(gridLayout);

       searchText = createSearchBar(parent);

       // getSite().setSelectionProvider(viewer);

    }

	private void createGridDataForViewerLayout() {

		GridData gridData = new GridData();

		gridData.verticalAlignment = GridData.FILL;

        gridData.horizontalSpan = 3;

        gridData.grabExcessHorizontalSpace = true;

        gridData.grabExcessVerticalSpace = true;

        gridData.horizontalAlignment = GridData.FILL;

        viewer.getControl().setLayoutData(gridData);

	}

    /**

     * @param parent

     * @return

     */

    private Text createSearchBar(Composite parent) {

        Label searchLabel = new Label(parent, SWT.NONE);

        searchLabel.setText(Messages.ChecklistEditor_SEARCH);

        final Text searchText = new Text(parent, SWT.BORDER | SWT.SEARCH | SWT.ICON_SEARCH | SWT.CANCEL);

        searchText.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL));

        searchText.setForeground(EditorUtil.getColor(Resources.SEARCH_VIEW_FOREGROUND));

        searchText.setText(TYPE_FILTER_TEXT);

        return searchText;

    }

    /**

     * @param parent

     */

    private void createToolbar(Composite parent) {

        ToolBar toolBar = new ToolBar(parent, SWT.NONE);

      //  toolItem = new ToolItem(toolBar, SWT.DROP_DOWN | SWT.BORDER);

        toolItem = new ToolItem(toolBar, SWT.BUTTON1);

        toolItem.setText(Messages.ChecklistEditor_DIST_STATUS);

        toolItem.setToolTipText(Messages.ChecklistEditor_DIST_STATUS_TOOLTIP);

        //createToolbarItems();

      //  toolItem.addSelectionListener(dropListener);

        toolItem.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent event) {

                AvailableDistributionWizard availableDistributionWizard = new AvailableDistributionWizard();

                WizardDialog dialog = new WizardDialog(StoreUtil.getShell(),

                        availableDistributionWizard);

                int open = dialog.open();

                if(open == 0){

                    reload();

                }

            }

        });

        toolBar.pack();

    }

	private void createToolbarItems() {

	    SortedSet<DefinedTermBase> termsList = getLabelProvider().getNamedAreas(false);

		dropListener = new ChecklistDropdownSelectionListenerE4(toolItem, this, termsList);

        for (DefinedTermBase<DefinedTermBase> term : termsList) {

            if(term!=null){

                dropListener.add(term);

            }

        }

	}

    private void createStatusBar(Composite composite) {

        GridData gridData = new GridData();

        gridData.horizontalSpan = 3;

        gridData.grabExcessHorizontalSpace = true;

        gridData.horizontalAlignment = GridData.FILL;

        statusLabel = new Label(composite, SWT.LEFT);

        statusLabel.setText(ELEMENT_COUNT + (countNodes != null ? countNodes : UNKNOWN));

        statusLabel.setLayoutData(gridData);

    }

    private void createTable() {

        Table table = viewer.getTable();//new Table(parent, viewer.getTable().getStyle());

        List<String> titles = new ArrayList<String>();

        List<Integer> bounds = new ArrayList<Integer>();

        if (PreferencesUtil.isShowRankInChecklistEditor()){

            Collections.addAll(titles, Messages.ChecklistEditor_TAXON,  Messages.ChecklistEditor_RANK);

            Collections.addAll(bounds, 300, 200);

        } else{

            Collections.addAll(titles, Messages.ChecklistEditor_TAXON);

            Collections.addAll(bounds, 300);

        }

      //  Map<Integer, Boolean> restoreValuesForColumnWidth =

        restoreValuesForColumnWidth(titles, bounds);

        createInitalDistributionColumns(table, titles, bounds);

        table.setSortDirection(SWT.DOWN);

        table.setHeaderVisible(true);

        table.setLinesVisible(true);

	}

    /**

     * This method creates initially the distribution columns for a table. It should only be called for creation.<br>

     *<p>

     *

     *<b>Notice:</b> If you want to add additional columns later please use <b>addTableViewerColumn()</b>

     *

     * @param table

     * @param titles

     * @param bounds

     * @param restoreValuesForColumnWidth

     */

	private void createInitalDistributionColumns(Table table,

			List<String> titles, List<Integer> bounds) {

		for (int columnIndex = 0; columnIndex < titles.size(); columnIndex++) {

            TableViewerColumn column = new TableViewerColumn(viewer, SWT.NONE);

            column.getColumn().setText(titles.get(columnIndex));

            column.getColumn().setWidth(bounds.get(columnIndex));

            column.getColumn().setResizable(true);

            column.getColumn().setMoveable(true);

            column.getColumn().addSelectionListener(getSelectionAdapter(column.getColumn(), columnIndex));

            if (columnIndex == 0) {

                table.setSortColumn(column.getColumn());

            }

            if (columnIndex == 1 && PreferencesUtil.isShowRankInChecklistEditor()) {

            	/** uncommented it for now because no rank editing is wanted **/

//                column.setEditingSupport(new RankEditingSupport(viewer, this));

            }

            if ((columnIndex == 1 && !PreferencesUtil.isShowRankInChecklistEditor()) || columnIndex >= 2 ) {

                //read PrefrenceStore to setWidth according to last saved state

//                if(restoreValuesForColumnWidth.get(columnIndex)){

                    column.getColumn().setWidth(50);

//                }else{

//                    column.getColumn().setWidth(0);

//                }

                column.setEditingSupport(new DistributionEditingSupportE4(viewer, this, columnIndex));

            }

        }

	}

    /**

     * This methods loads the last opened distribution columns for the table viewer from the prefrence store.<br>

     *<p>

     * <b>Notice:</b> It adds also the TitleCache to the titles list for the header of each column.<p>

     *

     * @param titles

     * @param bounds

     * @return Map<Integer, Boolean>

     */

	private void restoreValuesForColumnWidth(List<String> titles,

			List<Integer> bounds) {

//		Map<Integer, Boolean> restoreColumnWidth = new HashMap<Integer, Boolean>();

		if (labelProvider.getNamedAreas(true) != null) {

		    int columnIndex;

		    if (PreferencesUtil.isShowRankInChecklistEditor()){

		        columnIndex = 2;

		    } else{

		        columnIndex = 1;

		    }

            for (DefinedTermBase<DefinedTermBase> term : getLabelProvider().getNamedAreas(false)) {

                if(term != null){

                   // restoreColumnWidth.put(columnIndex, PreferencesUtil.getPreferenceStore().getBoolean(term.getUuid().toString()));

                    areaPosition.put(term.getUuid(), columnIndex);

                    if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){

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

                            titles.add(term.getIdInVocabulary());

                        } else{

                            titles.add(term.getTitleCache());

                        }

                    }else{

                        titles.add(term.getTitleCache());

                    }

                    bounds.add(200);

                    columnIndex++;

                }

            }

        }

//		return restoreColumnWidth;

	}

    /**

     * This method adds new DistributionColumns to an existing table.

     *

     * @param title

     * @param bound

     * @param colNumber

     * @return

     */

    private TableViewerColumn addTableViewerColumn(String title, int bound, final int colNumber, DefinedTermBase term) {

        final TableViewerColumn viewerColumn = new TableViewerColumn(viewer, SWT.FULL_SELECTION);

        final TableColumn column = viewerColumn.getColumn();

        column.setText(title);

        String[] UuidAndLable = new String[2];

        UuidAndLable[0] = term.getUuid().toString();

        UuidAndLable[1] = title;

        column.setData(UuidAndLable);

        column.setWidth(200);

        viewerColumn.setEditingSupport(new DistributionEditingSupportE4(viewer, this, colNumber));

        column.setResizable(true);

        column.setMoveable(true);

        return viewerColumn;

      }

    /**

     *

     * pull data from database and set input for view

     *

     */

    private void loadDataInput() {

        Classification classification = checklistEditorInput.getClassification();

        TaxonNode taxonNode = checklistEditorInput.getTaxonNode();

        if (classification != null && taxonNode == null) {

            countNodes = taxonNodeService.countAllNodesForClassification(classification);

//            statusLabel.setText(ELEMENT_COUNT + (countNodes != null ? countNodes : UNKNOWN));

            // This should not kill the view nor the editor if something goes

            // wrong

            // TODO: don't load the whole taxonNode Object but rather a small

            // and simple Solution

            // FIXME: May be don't open classification which are greater than

            // 3000 Taxa

            selectedTaxonNodes = taxonNodeService.listAllNodesForClassification(classification, 0, countNodes);

            countNodes = selectedTaxonNodes.size();

            statusLabel.setText(ELEMENT_COUNT + (countNodes != null ? countNodes : UNKNOWN));

            viewer.setInput(checklistEditorInput.getTaxa());

//            Job checkListJob = new ChecklistJob(LOADING_TAXA, selectedTaxonNodes);

//            checkListJob.schedule(Job.LONG);

        }

        if (taxonNode != null) {

        	boolean includeUnpublished = true;

            selectedTaxonNodes = taxonNodeService.loadChildNodesOfTaxonNode(taxonNode, NODE_INIT_STRATEGY, true, includeUnpublished, null);

            countNodes = selectedTaxonNodes.size();

            viewer.setInput(checklistEditorInput.getTaxa());

            statusLabel.setText(ELEMENT_COUNT + (countNodes != null ? countNodes : UNKNOWN));

//            Job checkListJob = new ChecklistJob(LOADING_TAXA, selectedTaxonNodes);

//            checkListJob.schedule(Job.LONG);

//          getService().schedule(new ChecklistJob(LOADING_TAXA, selectedTaxonNodes), Job.LONG);

        }

    }

    @PreDestroy

    public void dispose() {

    	if(conversation!=null){

    		conversation.unregisterForDataStoreChanges(this);

    		conversation.close();

    	}

    	conversation = null;

    	if(checklistEditorInput!=null){

    	    checklistEditorInput.dispose();

    	}

    }

    /** {@inheritDoc} */

    @Focus

    public void setFocus() {

    	if(viewer!=null && viewer.getControl()!=null && !viewer.getControl().isDisposed()) {

            viewer.getControl().setFocus();

        }

    }

    //FIXME E4 migrate

//    /*

//     * (non-Javadoc)

//     *

//     * @see org.eclipse.ui.part.WorkbenchPart#showBusy(boolean)

//     */

//    /** {@inheritDoc} */

//    @Override

//    public void showBusy(boolean busy) {

//        super.showBusy(busy);

//        // viewer.getTable().setEnabled(!busy);

//        if (busy) {

//            partNameCache = getPartName();

//            setPartName(String.format(Messages.ChecklistEditor_LOAD_CNT_TAXA, countNodes));

//        } else {

//            if (partNameCache != null) {

//                setPartName(partNameCache);

//            }

//        }

//    }

    /**

     * <p>

     * Getter for the field <code>viewer</code>.

     * </p>

     *

     * @return a {@link org.eclipse.jface.viewers.StructuredViewer} object.

     */

    public StructuredViewer getViewer() {

        return viewer;

    }

    public void refresh() {

        viewer.refresh();

    }

    /**

     * This method should only be called for adding new Distribution columns and reloading the table.<br>

     * It will hide the old distribution column and load the newly added columns.<br>

     * <p>

     * <b>Notice:</b> for data update please use <b>refresh()</b>

     *

     */

    @SuppressWarnings({ "unchecked", "rawtypes" })

	public void reload(){

    	//create new Items for Dropdown menue

    	Table table = viewer.getTable();

    	table.setRedraw(false);

    	Collection<DefinedTermBase> oldTerms = labelProvider.getNamedAreas(false);

//    	if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){

//

//    	} else{

//    	    terms = (SortedSet<DefinedTermBase>) labelProvider.getTermsOrderedByLabels(labelProvider.getNamedAreas(), CdmStore.getDefaultLanguage());

//    	}

    	SortedSet<DefinedTermBase> newTerms = labelProvider.getNamedAreas(true);

    	//terms = newTerms;

//    	toolItem.removeSelectionListener(dropListener);

////    	hideDistributionColumns(oldTerms);

//    	createToolbarItems();

//    	toolItem.addSelectionListener(dropListener);

    	//check which terms are deleted and which are new.

    	TableColumn[] columns = viewer.getTable().getColumns() ;

    	int index = 0;

      for (TableColumn column: columns){

          if ((!PreferencesUtil.isShowRankInChecklistEditor() && index > 0) || (index > 1)) {

                column.dispose();

            }

          index++;

      }

      if (oldTerms != null){

    	for (DefinedTermBase oldTerm:oldTerms){

            boolean delete = true;

            for (DefinedTermBase term: newTerms){

                   if(oldTerm.getUuid().equals(term.getUuid())){

                       delete = false;

                       break;

                   }

            }

            if (delete){

               // viewer.getTable().remove(areaPosition.get(oldTerm.getUuid()));

                areaPosition.remove(oldTerm.getUuid());

            }

        }

    	updateColumnIndex();

      }

    	for (DefinedTermBase term:newTerms){

    	    boolean isNew = true;

    	    Integer position = areaPosition.get(term.getUuid());

    	    String termLable = term.getTitleCache();;

            if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){

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

                    termLable = term.getIdInVocabulary();

                }

            }

            if (position == null){

                int count = viewer.getTable().getColumnCount();

                TableViewerColumn column= addTableViewerColumn(termLable, 200, count, term);

                areaPosition.put(term.getUuid(), Integer.valueOf(count));

            }else{

                TableViewerColumn column= addTableViewerColumn(termLable, 200, position, term);

            }

           // acitivateNewColumnInDropDownMenu(term);

    	}

//    	for(DefinedTermBase term:terms.values()){

//    		int count = viewer.getTable().getColumnCount();

//

//    		//add new terms

//    		for (TableColumn column: columns){

//    		    if (terms.){

//    		        break;

//    		    }

//    		}

//

////    		String termLable = term.getTitleCache();;

////    		if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){

////    			if (term.getIdInVocabulary() != null){

////    				termLable = term.getIdInVocabulary();

////    	        }

////    		}

////    		addTableViewerColumn(termLable, 200, count);

////    		acitivateNewColumnInDropDownMenu(term);

    //	}

        viewer.setLabelProvider(labelProvider);

//        getService().schedule(new ChecklistJob(LOADING_TAXA, selectedTaxonNodes), Job.LONG);

        table.setRedraw(true);

    	viewer.refresh();

    }

	/**

     *

     */

    private void updateColumnIndex() {

        int columnIndex;

        if (PreferencesUtil.isShowRankInChecklistEditor()){

            columnIndex = 2;

        } else{

            columnIndex = 1;

        }

        for (UUID uuid:areaPosition.keySet()){

            areaPosition.put(uuid, columnIndex);

            columnIndex++;

        }

    }

    private void acitivateNewColumnInDropDownMenu(DefinedTermBase term) {

		Menu menu = dropListener.getMenu();

		MenuItem[] items = menu.getItems();

		for(MenuItem item: items){

			if(item.getText().equalsIgnoreCase(term.getTitleCache())){

				item.setSelection(true);

				PreferencesUtil.getPreferenceStore().setValue(term.getUuid().toString(), true);

			}

		}

	}

	private void hideDistributionColumns(Collection<DefinedTermBase> oldTerms) {

		TableColumn[] columns = viewer.getTable().getColumns();

    	for(int i=4; i<columns.length; i++){

    		//remove all columns

    		columns[i].dispose();

    		Menu menu = dropListener.getMenu();

    		int itemCount = menu.getItemCount();

    		MenuItem item = menu.getItem(i-3);

    		item.setSelection(false);

    	}

    	if(oldTerms != null){

    		for(DefinedTermBase term : oldTerms){

    			PreferencesUtil.getPreferenceStore().setValue(term.getUuid().toString(), false);

    		}

    	}

	}

    /**

     * <p>

     * Getter for the field <code>service</code>.

     * </p>

     *

     * @return the service

     */

    public IWorkbenchSiteProgressService getService() {

        return TaxeditorEditorPlugin.getDefault().getWorkbench().getService(IWorkbenchSiteProgressService.class);

    }

    private SelectionAdapter getSelectionAdapter(final TableColumn column, final int index) {

        SelectionAdapter selectionAdapter = new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                comparator.setColumn(index);

                int dir = viewer.getTable().getSortDirection();

                if (viewer.getTable().getSortColumn() == column) {

                    dir = dir == SWT.UP ? SWT.DOWN : SWT.UP;

                } else {

                    dir = SWT.DOWN;

                }

                viewer.getTable().setSortDirection(dir);

                viewer.getTable().setSortColumn(column);

                viewer.refresh();

            }

        };

        return selectionAdapter;

    }

    public void doSave(IProgressMonitor monitor) {

        try {

            monitor.beginTask(Messages.ChecklistEditor_SAVE_EDITOR, 1);

            if (!conversation.isBound()) {

                conversation.bind();

            }

            this.checklistEditorInput.merge();

            conversation.commit(true);

            setDirty(false);

            monitor.worked(1);

        } finally {

            monitor.done();

        }

    }

    public void init(ChecklistEditorInput input) {

        checklistEditorInput = input;

        thisPart.setLabel(DISTRIBUTION_EDITOR+": " + checklistEditorInput.getName());

        conversation = checklistEditorInput.getConversation();

        conversation.registerForDataStoreChanges(this);

        //propagate selection

        selectionChangedListener = (event -> selService.setSelection(

               DistributionEditorHelper.getDistributionForColumn(event, areaPosition)));

        viewer.addSelectionChangedListener(selectionChangedListener);

        loadDataInput();

    }

    private static final List<String> NODE_INIT_STRATEGY = Arrays.asList(new String[] { "descriptions", //$NON-NLS-1$

            "descriptions.*", "description.state", "feature", "feature.*", "childNodes", "childNodes.taxon", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$

            "childNodes.taxon.name", "taxonNodes", "taxonNodes.*", "taxonNodes.taxon.*", "taxon.*", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$

            "taxon.descriptions", "taxon.sec", "taxon.name.*", "terms", "name.*", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$

            "name.rank.representations", "name.status.type.representations", "stateData.$" }); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

    /*

     * (non-Javadoc)

     *

     * @see

     * eu.etaxonomy.taxeditor.model.IDirtyMarkableSelectionProvider#changed(

     * java.lang.Object)

     */

    @Override

    public void changed(Object element) {

        if (element != null) {

            viewer.update(element, null);

            if (element instanceof Taxon){

                checklistEditorInput.addTaxonToSave((Taxon)element);

            }

            setDirty(true);

        }

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.model.IDirtyMarkableSelectionProvider#forceDirty()

     */

    @Override

    public void forceDirty() {

        changed(null);

    }

    public void setDirty(boolean dirty) {

        this.dirty.setDirty(dirty);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.ui.forms.editor.FormEditor#isDirty()

     */

    public boolean isDirty() {

        return dirty.isDirty();

    }

    /**

     * @return the labelProvider

     */

    public ChecklistLabelProvider getLabelProvider() {

        return labelProvider;

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.persistence.hibernate.ICdmPostDataChangeObserver#update(eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap)

     */

    @Override

    public void update(CdmDataChangeMap arg0) {

        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.conversation.IConversationEnabled#getConversationHolder()

     */

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart#save(org.eclipse.core.runtime.IProgressMonitor)

     */

    @Override

    @Persist

    public void save(IProgressMonitor monitor) {

        doSave(monitor);

    }

}