EDIT

package eu.etaxonomy.taxeditor.editor.view.derivate;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import javax.inject.Named;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.commands.operations.IOperationHistory;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.Status;

import org.eclipse.e4.core.contexts.ContextInjectionFactory;

import org.eclipse.e4.core.contexts.IEclipseContext;

import org.eclipse.e4.core.di.annotations.Optional;

import org.eclipse.e4.core.services.events.IEventBroker;

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.services.EMenuService;

import org.eclipse.e4.ui.services.IServiceConstants;

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

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

import org.eclipse.jface.util.LocalSelectionTransfer;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TreeNode;

import org.eclipse.jface.viewers.TreeSelection;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerComparator;

import org.eclipse.swt.SWT;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Tree;

import org.eclipse.ui.IMemento;

import org.eclipse.ui.ide.undo.WorkspaceUndoUtil;

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

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

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

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

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

import eu.etaxonomy.cdm.model.molecular.SingleRead;

import eu.etaxonomy.cdm.model.occurrence.FieldUnit;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

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

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

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

import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;

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

import eu.etaxonomy.taxeditor.editor.EditorUtil;

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

import eu.etaxonomy.taxeditor.editor.name.e4.TaxonNameEditorE4;

import eu.etaxonomy.taxeditor.editor.view.derivate.searchFilter.DerivateSearchCompositeController;

import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

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

import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;

import eu.etaxonomy.taxeditor.view.search.derivative.DerivateContentProvider;

import eu.etaxonomy.taxeditor.view.search.derivative.DerivateLabelProvider;

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

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

/**

 * Displays the derivate hierarchy of the specimen specified in the editor input.

 *

 */

public class DerivateView implements IPartContentHasFactualData, IConversationEnabled,

        ICdmEntitySessionEnabled, IDirtyMarkable, IPostOperationEnabled, IPartContentHasDetails, IPartContentHasSupplementalData, IPartContentHasMedia,

        IContextListener, IE4SavablePart, ICollapsableExpandable {

    private static final String SPECIMEN_EDITOR = Messages.DerivateView_SPECIMEN_EDITOR;

    public static final String ID = "eu.etaxonomy.taxeditor.editor.view.derivate.DerivateView"; //$NON-NLS-1$

    public static final String INPUT_ID = ID+".editorInput"; //$NON-NLS-1$

    public static final String YOU_NEED_TO_SAVE_BEFORE_PERFORMING_THIS_ACTION = Messages.DerivateView_YOU_NEED_TO_SAVE;

    public static final String VIEW_HAS_UNSAVED_CHANGES = Messages.DerivateView_UNSAVED_CHANGES;

    private static final List<String> SPECIMEN_INIT_STRATEGY = Arrays.asList(new String[] {

            "descriptions", //$NON-NLS-1$

            "annotations", //$NON-NLS-1$

            "markers", //$NON-NLS-1$

            "credits", //$NON-NLS-1$

            "extensions", //$NON-NLS-1$

            "rights", //$NON-NLS-1$

            "sources", //$NON-NLS-1$

            "derivationEvents.derivatives.annotations", //$NON-NLS-1$

            "derivationEvents.derivatives.markers", //$NON-NLS-1$

            "derivationEvents.derivatives.credits", //$NON-NLS-1$

            "derivationEvents.derivatives.extensions", //$NON-NLS-1$

            "derivationEvents.derivatives.rights", //$NON-NLS-1$

            "derivationEvents.derivatives.sources" //$NON-NLS-1$

    });

	private static final int WARN_THRESHOLD = 200;

	private ConversationHolder conversation;

	private TreeViewer viewer;

    private final int dndOperations = DND.DROP_MOVE;

    private DerivateLabelProvider labelProvider;

    private DerivateContentProvider contentProvider;

    private DerivateSearchCompositeController derivateSearchCompositeController;

    @Inject

    private IEventBroker eventBroker;

    /**

     * A map with keys being the derivative entities belonging to the {@link UUID}s passed to the constructor

     * and values being the root elements of the hierarchy (may be the same objects as the derivative entities)

     */

    private Map<SpecimenOrObservationBase<?>, SpecimenOrObservationBase<?>> derivateToRootEntityMap;

    /**

     * The set of root elements

     */

    private Set<SpecimenOrObservationBase<?>> rootElements;

    private ICdmEntitySession cdmEntitySession;

    /**

     * <code>true</code> if this view is listening to selection  changes

     */

    private boolean listenToSelectionChange;

    private Taxon selectedTaxon;

    @Inject

    private ESelectionService selService;

    @Inject

    private MDirtyable dirty;

    private ISelectionChangedListener selectionChangedListener;

    private Set<AbstractPostOperation> operations = new HashSet<>();

    @Inject

    private MPart thisPart;

    /**

     * Default constructor

     */

    @Inject

    public DerivateView() {

    }

    /**

     * {@inheritDoc}

     */

    public void init(DerivateViewEditorInput editorInput){

        this.derivateToRootEntityMap = new HashMap<>();

        this.rootElements = new HashSet<>();

        //init tree

        Collection<UUID> derivativeUuids = editorInput.getDerivativeUuids();

        checkWarnThreshold(derivativeUuids);

        updateRootEntities(derivativeUuids);

        //set taxon filter

        derivateSearchCompositeController.setTaxonFilter(editorInput.getTaxonUuid());

        //reset status bar

        //TODO e4

//        getEditorSite().getActionBars().getStatusLineManager().setMessage(""); //$NON-NLS-1$

    }

    @PostConstruct

    public void createPartControl(Composite parent, EMenuService menuService,

            IEclipseContext context) {

        if (CdmStore.isActive()){

            if(conversation == null){

                conversation = CdmStore.createConversation();

            }

            if(cdmEntitySession == null){

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

            }

        }

        else{

            return;

        }

        //listen to context changes

        CdmStore.getContextManager().addContextListener(this);

        parent.setLayout(new GridLayout());

        //---search and filter---

        derivateSearchCompositeController = new DerivateSearchCompositeController(parent, this);

        GridData gridDataSearchBar = new GridData();

        gridDataSearchBar.horizontalAlignment = GridData.FILL;

        gridDataSearchBar.grabExcessHorizontalSpace = true;

        derivateSearchCompositeController.setLayoutData(gridDataSearchBar);

        derivateSearchCompositeController.setEnabled(CdmStore.isActive());

        //---tree viewer---

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

        GridData gridDataTree = new GridData();

        gridDataTree.horizontalAlignment = GridData.FILL;

        gridDataTree.verticalAlignment = GridData.FILL;

        gridDataTree.grabExcessVerticalSpace = true;

        gridDataTree.grabExcessHorizontalSpace = true;

        viewer.getTree().setLayoutData(gridDataTree);

        contentProvider = new DerivateContentProvider();

        viewer.setContentProvider(contentProvider);

        labelProvider = new DerivateLabelProvider();

        labelProvider.setConversation(conversation);

        viewer.setLabelProvider(labelProvider);

        viewer.getTree().setEnabled(CdmStore.isActive());

        //propagate selection

        selectionChangedListener = (event -> selService.setSelection(event.getSelection()));

        viewer.addSelectionChangedListener(selectionChangedListener);

        //create context menu

        menuService.registerContextMenu(viewer.getControl(), "eu.etaxonomy.taxeditor.editor.popupmenu.specimeneditor");

        //add drag'n'drop support

        Transfer[] transfers = new Transfer[] {LocalSelectionTransfer.getTransfer(),};

        viewer.addDragSupport(dndOperations, transfers, new DerivateDragListener(this));

        DerivateDropListener dropListener = new DerivateDropListener(this);

        ContextInjectionFactory.inject(dropListener, context);

        viewer.addDropSupport(dndOperations, transfers, dropListener);

    }

    public void updateRootEntities() {

        updateRootEntities((Collection)null);

    }

    public void updateRootEntities(Collection<UUID> derivativeUuids) {

        if(conversation!=null){

            if (!conversation.isBound()) {

                conversation.bind();

            }

            /*

             * If the active session is not the session of the Derivative Editor

             * then we will save the active session for later, bind temporarily

             * to our session and rebind to the original session when we are

             * done. This happens e.g. if a selection change happens in the

             * taxon editor and "Link with editor" is enabled. The selection

             * change event and thus the loading in updateRootEntities() happens

             * in the session of the taxon editor.

             */

            ICdmEntitySession previousCdmEntitySession = CdmStore.getCurrentSessionManager().getActiveSession();

            if(cdmEntitySession != null) {

                cdmEntitySession.bind();

            }

            eventBroker.post(WorkbenchEventConstants.CURRENT_ACTIVE_EDITOR, null);

            List<SpecimenOrObservationBase> derivates = null;

            if(derivativeUuids!=null){

                this.derivateToRootEntityMap = new HashMap<>();

                this.rootElements = new HashSet<>();

                derivates = CdmStore.getService(IOccurrenceService.class).load(new ArrayList(derivativeUuids), SPECIMEN_INIT_STRATEGY);

            }

            updateRootEntities(derivates);

            if(previousCdmEntitySession!=null){

                previousCdmEntitySession.bind();

            }

        }

    }

    public void updateRootEntities(List<SpecimenOrObservationBase> derivates) {

        if(derivates!=null){

            eventBroker.post(WorkbenchEventConstants.CURRENT_ACTIVE_EDITOR, null);

            this.derivateToRootEntityMap = new HashMap<>();

            this.rootElements = new HashSet<>();

            for (SpecimenOrObservationBase derivate : derivates) {

                if(derivate instanceof FieldUnit){

                    derivateToRootEntityMap.put(derivate, derivate);

                }

                else {

                    SpecimenOrObservationBase<?> topMostDerivate = EditorUtil.getTopMostDerivate(derivate);

                    if(topMostDerivate!=null){

                        derivateToRootEntityMap.put(derivate, topMostDerivate);

                    }

                    else{

                        derivateToRootEntityMap.put(derivate, derivate);

                    }

                }

            }

            for (SpecimenOrObservationBase<?> specimen : derivateToRootEntityMap.values()) {

                rootElements.add(specimen);

            }

        }

        labelProvider.updateLabelCache(rootElements);

        viewer.setInput(rootElements);

        viewer.setComparator(new ViewerComparator() {

    		@Override

    		@SuppressWarnings("unchecked")

               public int compare(Viewer testViewer, Object e1, Object e2) {

    			if (((TreeNode)e1).getValue() instanceof SpecimenOrObservationBase){

    				return ((SpecimenOrObservationBase)((TreeNode)e1).getValue()).getTitleCache().compareTo(((SpecimenOrObservationBase)((TreeNode)e2).getValue()).getTitleCache());

    			}else{

    				return e1.toString().compareTo(e2.toString());

    			}

    			//return (((SpecimenOrObservationBase) e1).getTitleCache()).compareTo(((SpecimenOrObservationBase) e2).getTitleCache());

    		}

    	});

        //TODO e4

        //            getEditorSite().getActionBars().getStatusLineManager().setMessage(String.format(Messages.DerivateView_CNT_DERIVATIVES_FOUND, rootElements.size()));

        //set selection to derivatives if the filter criteria

        //taxon assignment or derivative type are set

        if(derivates!=null && !derivateSearchCompositeController.isDefaultSearch()){

            List<TreeNode> nodesToSelect = new ArrayList<>();

            for (SpecimenOrObservationBase specimenOrObservationBase : derivates) {

                nodesToSelect.add(new TreeNode(specimenOrObservationBase));

            }

            setSelection(new StructuredSelection(nodesToSelect));

        }

        else{

            setSelection(null);

        }

    }

    private void setSelection(StructuredSelection selection){

        viewer.removeSelectionChangedListener(selectionChangedListener);

        viewer.setSelection(selection);

        viewer.addSelectionChangedListener(selectionChangedListener);

    }

    public void updateLabelCache(){

        labelProvider.updateLabelCache(rootElements);

    }

    @Persist

    @Override

    public void save(IProgressMonitor monitor) {

        String taskName = Messages.DerivateView_SAVING_HIERARCHY;

        monitor.beginTask(taskName, 3);

        if (!conversation.isBound()) {

            conversation.bind();

            if (!cdmEntitySession.isActive()){

                cdmEntitySession.bind();

            }

        }

        monitor.worked(1);

        // commit the conversation and start a new transaction immediately

        conversation.commit(true);

        for(AbstractPostOperation entry:operations){

            IStatus status = Status.CANCEL_STATUS;

            final IAdaptable uiInfoAdapter = WorkspaceUndoUtil

                    .getUIInfoAdapter(AbstractUtility.getShell());

            String operationlabel = entry.getLabel();

            try {

                entry.addContext(IOperationHistory.GLOBAL_UNDO_CONTEXT);

                status = entry.execute(new NullProgressMonitor(), uiInfoAdapter);

            } catch (ExecutionException e) {

                MessagingUtils.operationDialog(AbstractUtility.class, e, TaxeditorStorePlugin.PLUGIN_ID, operationlabel, null);

            }

            String statusString = status.equals(Status.OK_STATUS) ? "completed"

                    : "cancelled";

            IPostOperationEnabled postOperationEnabled = entry

                    .getPostOperationEnabled();

            if (postOperationEnabled != null) {

                postOperationEnabled.onComplete();

            }

            //AbstractUtility.executeOperation(entry,sync);

        }

        operations.clear();

        CdmStore.getService(IOccurrenceService.class).merge(new ArrayList<>(rootElements), true);

        monitor.worked(1);

        this.setDirty(false);

        monitor.worked(1);

        monitor.done();

        dirty.setDirty(false);

        refreshTree();

    }

    /**

     * @param isDirty the isDirty to set

     */

    public void setDirty(boolean isDirty) {

        dirty.setDirty(isDirty);

    }

    public Set<AbstractPostOperation> getOperations() {

        return operations;

    }

    public void addOperation(AbstractPostOperation operation) {

        this.operations.add(operation);

    }

    @Focus

    public void setFocus() {

        //make sure to bind again if maybe in another view the conversation was unbound

        if(conversation!=null && !conversation.isBound()){

            conversation.bind();

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.bind();

        }

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

            viewer.getControl().setFocus();

            selService.setSelection(viewer.getSelection());

        }

    }

    @Override

    public void update(CdmDataChangeMap changeEvents) {

    }

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    @Override

    public void changed(Object element) {

        setDirty(true);

        //firePropertyChange(IEditorPart.PROP_DIRTY);

        viewer.update(new TreeNode(element), null);

        viewer.refresh();

    }

    @Override

    public void forceDirty() {

        changed(null);

    }

    @Override

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

        List<String> specimenPropertyPaths = Arrays.asList(new String[] {

                "descriptions", //$NON-NLS-1$

                "derivationEvents.derivates", //$NON-NLS-1$

                "annotations", //$NON-NLS-1$

                "markers", //$NON-NLS-1$

                "credits", //$NON-NLS-1$

                "extensions", //$NON-NLS-1$

                "rights", //$NON-NLS-1$

                "sources" //$NON-NLS-1$

        });

        Map<Object, List<String>> specimenPropertyPathMap =

                new HashMap<>();

        specimenPropertyPathMap.put(SpecimenOrObservationBase.class,specimenPropertyPaths);

        return specimenPropertyPathMap;

    }

    /**

     * Refreshes the derivate hierarchy tree and expands the tree

     * to show and select the given object.

     *

     * @param expandTo the object to which the tree should be expanded

     */

    public void refreshTree(Object expandTo){

        refreshTree();

        TreeSelection selection = (TreeSelection) viewer.getSelection();

        viewer.expandToLevel(selection.getFirstElement(), 1);

        viewer.setSelection(new StructuredSelection(new TreeNode(expandTo)));

    }

    /**

     * Refreshes the derivate hierarchy tree

     */

    public void refreshTree(){

    	if(!viewer.getTree().isDisposed()){

    		viewer.refresh();

    	}

    }

    //FIXME:Remoting hack to make this work for remoting

    //This should actually be resolved using remoting post operations

    public void remove(Object obj) {

        if (obj instanceof TreeNode){

            obj = ((TreeNode)obj).getValue();

        }

        rootElements.remove(obj);

        Object o = this.derivateToRootEntityMap.remove(obj);

        viewer.setInput(rootElements);

    }

    /**

     * @return a set of {@link SingleRead}s that have multiple parents

     */

    public Set<SingleRead> getMultiLinkSingleReads() {

        return DerivateLabelProvider.getMultiLinkSingleReads();

    }

    public Object getSelectionInput() {

        return selectedTaxon;

    }

    public DerivateLabelProvider getLabelProvider() {

        return labelProvider;

    }

    @Override

    public boolean postOperation(Object objectAffectedByOperation) {

        refreshTree();

        if(objectAffectedByOperation!=null){

            changed(objectAffectedByOperation);

        }

        return true;

    }

    @Override

    public boolean onComplete() {

        return true;

    }

    @Override

    public boolean canAttachMedia() {

        return true;

    }

    public void addFieldUnit(FieldUnit fieldUnit) {

        rootElements.add(fieldUnit);

        derivateToRootEntityMap.put(fieldUnit, fieldUnit);

    }

    @Override

    public ICdmEntitySession getCdmEntitySession() {

        return cdmEntitySession;

    }

    @PreDestroy

    public void dispose() {

        if(conversation!=null){

            conversation.close();

            conversation = null;

        }

        if(cdmEntitySession != null) {

            cdmEntitySession.dispose();

            cdmEntitySession = null;

        }

        dirty.setDirty(false);

    }

    @Inject

    @Optional

    public void selectionChanged(@Optional @Named(IServiceConstants.ACTIVE_SELECTION) IStructuredSelection selection,

            @Named(IServiceConstants.ACTIVE_PART) MPart activePart, MPart thisPart){

        if(activePart == thisPart || viewer==null){

            return;

        }

        if(viewer.getTree().isDisposed()){

            return;

        }

        if(listenToSelectionChange){

            selectedTaxon = null;

            if(activePart.getObject() instanceof TaxonNameEditorE4){

                selectedTaxon = ((TaxonNameEditorE4) activePart.getObject()).getTaxon();

            }

            else if(selection != null){

                Object selectedElement = selection.getFirstElement();

                if(selectedElement instanceof TaxonNodeDto){

                    TaxonBase taxonBase = CdmStore.getService(ITaxonService.class).load(((TaxonNodeDto)selectedElement).getTaxonUuid());

                    if(HibernateProxyHelper.isInstanceOf(taxonBase, Taxon.class)){

                        selectedTaxon = HibernateProxyHelper.deproxy(taxonBase, Taxon.class);

                    }

                    else if(selectedElement instanceof TaxonNode){

                        selectedTaxon = HibernateProxyHelper.deproxy(selectedElement, TaxonNode.class).getTaxon();

                    }

                    else if(selectedElement instanceof Taxon){

                        selectedTaxon = HibernateProxyHelper.deproxy(selectedElement, Taxon.class);

                    }

                }

            }

            if(selectedTaxon!=null){

                Collection<SpecimenOrObservationBase> fieldUnits = CdmStore.getService(IOccurrenceService.class).listFieldUnitsByAssociatedTaxon(selectedTaxon, null, null);

                Collection<UUID> uuids = new HashSet<>();

                for (SpecimenOrObservationBase specimenOrObservationBase : fieldUnits) {

                    uuids.add(specimenOrObservationBase.getUuid());

                }

                checkWarnThreshold(uuids);

                updateRootEntities(uuids);

                thisPart.setLabel(SPECIMEN_EDITOR+": " + selectedTaxon.getName()); //$NON-NLS-1$

            }

            else{

                updateRootEntities((Collection<UUID>)Collections.EMPTY_LIST);

            }

        }

    }

	private void checkWarnThreshold(Collection<UUID> uuids) {

		if(uuids!=null && uuids.size()>WARN_THRESHOLD){

			MessagingUtils.warningDialog(Messages.DerivateView_PERF_WARNING, this.getClass(), String.format(Messages.DerivateView_PERF_WARNING_MESSAGE, uuids.size()));

			uuids.clear();

		}

	}

    public TreeViewer getViewer() {

        return viewer;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public List<SpecimenOrObservationBase<?>> getRootEntities() {

        return new ArrayList<>(rootElements);

    }

    public void toggleListenToSelectionChange(MPart part) {

        listenToSelectionChange = !listenToSelectionChange;

        derivateSearchCompositeController.setEnabled(!listenToSelectionChange);

        if(!listenToSelectionChange){

            selectedTaxon = null;

            part.setLabel(SPECIMEN_EDITOR);

        }

        else if(selectedTaxon==null){

            part.setLabel(SPECIMEN_EDITOR+Messages.DerivateView_NO_TAXON_SELECTED);

        }

    }

    public boolean isListenToSelectionChange(){

        return listenToSelectionChange;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void contextAboutToStop(IMemento memento, IProgressMonitor monitor) {

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void contextStop(IMemento memento, IProgressMonitor monitor) {

        //close view when workbench closes

        try{

            thisPart.getContext().get(EPartService.class).hidePart(thisPart);

        }

        catch(Exception e){

            //nothing

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void contextStart(IMemento memento, IProgressMonitor monitor) {

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void contextRefresh(IProgressMonitor monitor) {

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {

    }

    @Override

    public boolean isDirty() {

        return dirty.isDirty();

    }

    @Override

    public void collapse() {

        viewer.collapseAll();

    }

    @Override

    public void expand() {

        viewer.expandAll();

    }

}