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;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.SortedSet;

import org.apache.log4j.Logger;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.StructuredViewer;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TableViewerColumn;

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.events.SelectionListener;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

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

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.IMemento;

import org.eclipse.ui.ISelectionListener;

import org.eclipse.ui.ISelectionService;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.part.EditorPart;

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.hibernate.HibernateProxyHelper;

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

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

import eu.etaxonomy.taxeditor.editor.view.checklist.edit.DistributionEditingSupport;

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

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

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

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

import eu.etaxonomy.taxeditor.model.IContextListener;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasFactualData;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.preference.Resources;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * <p>

 * ChecklistViewPart class.

 * </p>

 *

 * @author a.oppermann

 * @created 30.04.2014

 * @version 1.0

 */

public class ChecklistEditor extends EditorPart implements ISelectionListener, IPartContentHasFactualData, IConversationEnabled,

        IContextListener, IDirtyMarkable, IPartContentHasDetails{

    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(ChecklistEditor.class);

    private class ChecklistJob extends Job {

        private List<TaxonNode> taxonNodes;

        /**

         * @param name

         */

        public ChecklistJob(String title, List<TaxonNode> listTaxonNodes) {

            super(title);

            this.taxonNodes = listTaxonNodes;

        }

        /*

         * (non-Javadoc)

         *

         * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.

         * IProgressMonitor)

         */

        @Override

        public IStatus run(final IProgressMonitor monitor) {

            try {

                logger.debug("Begin of eclipse core runtime Job to Retrieve datasources"); //$NON-NLS-1$

                monitor.beginTask(Messages.ChecklistEditor_RETRIEVE_NODES, taxonNodes.size() + 1);

                final List<Taxon> taxonList = new ArrayList<Taxon>();

                for (TaxonNode taxonNode : taxonNodes) {

                    HibernateProxyHelper hh = new HibernateProxyHelper();

                    Taxon taxon = hh.deproxy(taxonNode.getTaxon(), Taxon.class);

                    taxonList.add(taxon);

                }

                // set View input

                Display.getDefault().asyncExec(new Runnable() {

                    @Override

                    public void run() {

                    	viewer.setInput(taxonList);

                    }

                });

                monitor.worked(1);

            } finally {

                monitor.done();

                taxonNodes = null;

            }

            return Status.OK_STATUS;

        }

    }

    /**

     * 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 String partNameCache;

    private IWorkbenchSiteProgressService service;

    private ITaxonNodeService taxonNodeService;

    private ChecklistEditorComparator comparator;

    private ChecklistEditorInput checklistEditorInput;

    private SimpleSelectionProvider simpleSelectionProvider;

    private ISelectionService selectionService;

    private ConversationHolder conversation;

    private Integer countNodes;

    private List<TaxonNode> selectedTaxonNodes;

    private boolean dirty;

    private ChecklistEditorFilter filter;

    private Menu headerMenu;

    private Label statusLabel;

    private ICdmEntitySession cdmEntitySession;

    private ChecklistLabelProvider labelProvider;

    private SortedSet<DefinedTermBase> terms = null;

	private ToolItem toolItem;

	private ChecklistDropdownSelectionListener dropListener;

    /**

     * @return the selectedTaxonNodes

     */

    public List<TaxonNode> getSelectedTaxonNodes() {

        return selectedTaxonNodes;

    }

    /**

     * @param selectedTaxonNodes

     *            the selectedTaxonNodes to set

     */

    public void setSelectedTaxonNodes(List<TaxonNode> selectedTaxonNodes) {

        this.selectedTaxonNodes = selectedTaxonNodes;

    }

    /**

     * <p>

     * Constructor for CdmDataSourceViewPart.

     * </p>

     */

    public ChecklistEditor() {

        //cdmEntitySession = CdmStore.getCurrentSessionManager().newSession(this, true);

    }

    /** {@inheritDoc} */

    @Override

    public void createPartControl(Composite parent) {

        service = (IWorkbenchSiteProgressService) getSite().getAdapter(IWorkbenchSiteProgressService.class);

        taxonNodeService = CdmStore.getService(ITaxonNodeService.class);

        selectionService = getSite().getWorkbenchWindow().getSelectionService();

        selectionService.addSelectionListener(this);

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

//        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);

        terms = labelProvider.getNamedAreas();

        if (terms == null){

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

			this.dispose();

			return;

		}

        filter = new ChecklistEditorFilter();

        createTopComposite(parent);

        loadDataInput();

    }

    /**

     * @param parent

     */

    private void createTopComposite(Composite parent) {

        GridLayout gridLayout = new GridLayout(3, false);

        gridLayout.marginWidth = 0;

        gridLayout.marginHeight = 0;

        parent.setLayout(gridLayout);

        final Text searchText = createSearchBar(parent);

        createToolbar(parent);

       // getSite().setSelectionProvider(viewer);

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

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

        searchText.addModifyListener(modifyListener);

        createGridDataForViewerLayout();

        viewer.addFilter(filter);

        createTable();

        viewer.setContentProvider(new ChecklistContentProvider());

        viewer.setLabelProvider(this.labelProvider);

        comparator = new ChecklistEditorComparator();

        viewer.setComparator(comparator);

        createStatusBar(parent);

    }

	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.setText(Messages.ChecklistEditor_DIST_STATUS);

        toolItem.setToolTipText(Messages.ChecklistEditor_DIST_STATUS_TOOLTIP);

        createToolbarItems();

        toolItem.addSelectionListener(dropListener);

        toolBar.pack();

    }

	private void createToolbarItems() {

		dropListener = new ChecklistDropdownSelectionListener(toolItem, this, terms);

        for (DefinedTermBase<DefinedTermBase> term : terms) {

            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, restoreValuesForColumnWidth);

        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, Map<Integer, Boolean> restoreValuesForColumnWidth) {

		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(50);

                }

                column.setEditingSupport(new DistributionEditingSupport(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 Map<Integer, Boolean> restoreValuesForColumnWidth(List<String> titles,

			List<Integer> bounds) {

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

		if (terms != null) {

		    int columnIndex;

		    if (PreferencesUtil.isShowRankInChecklistEditor()){

		        columnIndex = 2;

		    } else{

		        columnIndex = 1;

		    }

            for (DefinedTermBase<DefinedTermBase> term : terms) {

                if(term != null){

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

                    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) {

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

        final TableColumn column = viewerColumn.getColumn();

        column.setText(title);

        column.setWidth(200);

        viewerColumn.setEditingSupport(new DistributionEditingSupport(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));

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

        }

        if (taxonNode != null) {

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

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

            countNodes = selectedTaxonNodes.size();

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

        }

    }

    /** {@inheritDoc} */

    @Override

    public void dispose() {

//    	this.checklistEditorInput.dispose();

    	super.dispose();

        conversation.unregisterForDataStoreChanges(this);

        conversation.unbind();

        //conversation.close();

		conversation = null;

    }

    /** {@inheritDoc} */

    @Override

    public void setFocus() {

        viewer.getControl().setFocus();

    }

    /*

     * (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);

    	SortedSet<DefinedTermBase> oldTerms = terms;

//    	if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){

//

//    	} else{

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

//    	}

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

    	toolItem.removeSelectionListener(dropListener);

    	hideDistributionColumns(oldTerms);

    	createToolbarItems();

    	toolItem.addSelectionListener(dropListener);

    	for(DefinedTermBase term:newTerms){

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

    		addTableViewerColumn(term.getTitleCache(), 200, count);

    		acitivateNewColumnInDropDownMenu(term);

    	}

        viewer.setLabelProvider(labelProvider);

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

        table.setRedraw(true);

    	viewer.refresh();

    }

	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(SortedSet<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 service;

    }

    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;

    }

    @Override

    public void doSave(IProgressMonitor monitor) {

        try {

            monitor.beginTask(Messages.ChecklistEditor_SAVE_EDITOR, 1);

            if (!conversation.isBound()) {

                conversation.bind();

            }

            CdmStore.getService(ITaxonNodeService.class).merge(selectedTaxonNodes, true);

            //this.checklistEditorInput.merge();

            conversation.commit(true);

            setDirty(false);

            monitor.worked(1);

        } finally {

            monitor.done();

        }

    }

    @Override

    public void doSaveAs() {

    }

    @Override

    public void init(IEditorSite site, IEditorInput input) throws PartInitException {

        setSite(site);

        setInput(input);

        if (input instanceof ChecklistEditorInput) {

            checklistEditorInput = (ChecklistEditorInput) input;

            setPartName(getPartName() + ": " + checklistEditorInput.getName()); //$NON-NLS-1$

            conversation = checklistEditorInput.getConversation();

            conversation.registerForDataStoreChanges(this);

        }

        simpleSelectionProvider = new SimpleSelectionProvider();

        getSite().setSelectionProvider(simpleSelectionProvider);

    }

    @Override

    public boolean isSaveAsAllowed() {

        return false;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.ui.ISelectionListener#selectionChanged(org.eclipse.ui.

     * IWorkbenchPart, org.eclipse.jface.viewers.ISelection)

     */

    @Override

    public void selectionChanged(IWorkbenchPart part, ISelection selection) {

//    	System.out.println(selection.getClass().getSimpleName());

//    	viewer.setSelection(selection, true);

    }

    /*

     * (non-Javadoc)

     *

     * @see

     * eu.etaxonomy.taxeditor.model.IContextListener#contextAboutToStop(org.

     * eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)

     */

    @Override

    public void contextAboutToStop(IMemento memento, IProgressMonitor monitor) {

    }

    /*

     * (non-Javadoc)

     *

     * @see

     * eu.etaxonomy.taxeditor.model.IContextListener#contextStop(org.eclipse

     * .ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)

     */

    @Override

    public void contextStop(IMemento memento, IProgressMonitor monitor) {

//        IStructuredSelection sel = (IStructuredSelection) this.viewer.getSelection();

//        if (sel.isEmpty()) {

//            return;

//        }

//        memento = memento.createChild("tree-selections");

//        Iterator iter = sel.iterator();

//        while (iter.hasNext()) {

//            String nodeName = (String) iter.next();

//            memento.createChild("selected-nodes", nodeName);

//        }

    }

    /*

     * (non-Javadoc)

     *

     * @see

     * eu.etaxonomy.taxeditor.model.IContextListener#contextStart(org.eclipse

     * .ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)

     */

    @Override

    public void contextStart(IMemento memento, IProgressMonitor monitor) {

    }

    /*

     * (non-Javadoc)

     *

     * @see

     * eu.etaxonomy.taxeditor.model.IContextListener#contextRefresh(org.eclipse

     * .core.runtime.IProgressMonitor)

     */

    @Override

    public void contextRefresh(IProgressMonitor monitor) {

    }

    /*

     * (non-Javadoc)

     *

     * @see

     * eu.etaxonomy.taxeditor.model.IContextListener#workbenchShutdown(org.eclipse

     * .ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)

     */

    @Override

    public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {

        conversation.clear();

        conversation.close();

        conversation = null;

    }

    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);

            setDirty(true);

            firePropertyChange(PROP_DIRTY);

        }

    }

    /* (non-Javadoc)

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

     */

    @Override

    public void forceDirty() {

        changed(null);

    }

    public void setDirty(boolean dirty) {

        this.dirty = dirty;

        firePropertyChange(PROP_DIRTY);

    }

    /*

     * (non-Javadoc)

     *

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

     */

    @Override

    public boolean isDirty() {

        return dirty;

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled#getCdmEntitySession()

     */

//    /* (non-Javadoc)

//     * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled#getRootEntities()

//     */

//    @Override

//    public <T extends CdmBase> Collection<T> getRootEntities() {

//        // TODO Auto-generated method stub

//        return null;

//    }

//

//    /* (non-Javadoc)

//     * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled#getPropertyPathsMap()

//     */

//    @Override

//    public Map<Object, List<String>> getPropertyPathsMap() {

//        // TODO Auto-generated method stub

//        return null;

//    }

    /**

     * @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;

    }

}