eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/derivate/DerivateView.java

   1 package eu.etaxonomy.taxeditor.editor.view.derivate;
   2
   3 import java.util.ArrayList;
   4 import java.util.Arrays;
   5 import java.util.Collection;
   6 import java.util.Collections;
   7 import java.util.HashMap;
   8 import java.util.HashSet;
   9 import java.util.List;
  10 import java.util.Map;
  11 import java.util.Set;
  12 import java.util.UUID;
  13
  14 import javax.annotation.PostConstruct;
  15 import javax.annotation.PreDestroy;
  16 import javax.inject.Inject;
  17 import javax.inject.Named;
  18
  19 import org.eclipse.core.runtime.IProgressMonitor;
  20 import org.eclipse.e4.core.di.annotations.Optional;
  21 import org.eclipse.e4.ui.di.Focus;
  22 import org.eclipse.e4.ui.di.Persist;
  23 import org.eclipse.e4.ui.model.application.ui.MDirtyable;
  24 import org.eclipse.e4.ui.model.application.ui.basic.MPart;
  25 import org.eclipse.e4.ui.services.EMenuService;
  26 import org.eclipse.e4.ui.services.IServiceConstants;
  27 import org.eclipse.e4.ui.workbench.modeling.EPartService;
  28 import org.eclipse.e4.ui.workbench.modeling.ESelectionService;
  29 import org.eclipse.jface.util.LocalSelectionTransfer;
  30 import org.eclipse.jface.viewers.AbstractTreeViewer;
  31 import org.eclipse.jface.viewers.ISelection;
  32 import org.eclipse.jface.viewers.ISelectionChangedListener;
  33 import org.eclipse.jface.viewers.IStructuredSelection;
  34 import org.eclipse.jface.viewers.StructuredSelection;
  35 import org.eclipse.jface.viewers.TreeNode;
  36 import org.eclipse.jface.viewers.TreeSelection;
  37 import org.eclipse.jface.viewers.TreeViewer;
  38 import org.eclipse.swt.SWT;
  39 import org.eclipse.swt.dnd.DND;
  40 import org.eclipse.swt.dnd.Transfer;
  41 import org.eclipse.swt.layout.GridData;
  42 import org.eclipse.swt.layout.GridLayout;
  43 import org.eclipse.swt.widgets.Composite;
  44 import org.eclipse.swt.widgets.Tree;
  45 import org.eclipse.ui.IMemento;
  46
  47 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
  48 import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
  49 import eu.etaxonomy.cdm.api.service.IOccurrenceService;
  50 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  51 import eu.etaxonomy.cdm.model.common.CdmBase;
  52 import eu.etaxonomy.cdm.model.molecular.SingleRead;
  53 import eu.etaxonomy.cdm.model.occurrence.FieldUnit;
  54 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  55 import eu.etaxonomy.cdm.model.taxon.Taxon;
  56 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  57 import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
  58 import eu.etaxonomy.taxeditor.editor.EditorUtil;
  59 import eu.etaxonomy.taxeditor.editor.MultiPageTaxonEditor;
  60 import eu.etaxonomy.taxeditor.editor.l10n.Messages;
  61 import eu.etaxonomy.taxeditor.editor.view.derivate.searchFilter.DerivateSearchCompositeController;
  62 import eu.etaxonomy.taxeditor.model.AbstractUtility;
  63 import eu.etaxonomy.taxeditor.model.IContextListener;
  64 import eu.etaxonomy.taxeditor.model.IDirtyMarkable;
  65 import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;
  66 import eu.etaxonomy.taxeditor.model.IPartContentHasFactualData;
  67 import eu.etaxonomy.taxeditor.model.IPartContentHasMedia;
  68 import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;
  69 import eu.etaxonomy.taxeditor.model.MessagingUtils;
  70 import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
  71 import eu.etaxonomy.taxeditor.session.ICdmEntitySession;
  72 import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
  73 import eu.etaxonomy.taxeditor.store.CdmStore;
  74 import eu.etaxonomy.taxeditor.view.derivateSearch.DerivateContentProvider;
  75 import eu.etaxonomy.taxeditor.view.derivateSearch.DerivateLabelProvider;
  76 import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;
  77
  78 /**
  79  * Displays the derivate hierarchy of the specimen specified in the editor input.
  80  *
  81  */
  82 public class DerivateView implements IPartContentHasFactualData, IConversationEnabled,
  83         ICdmEntitySessionEnabled, IDirtyMarkable, IPostOperationEnabled, IPartContentHasDetails, IPartContentHasSupplementalData, IPartContentHasMedia,
  84         IContextListener, IE4SavablePart {
  85
  86     private static final String SPECIMEN_EDITOR = Messages.DerivateView_SPECIMEN_EDITOR;
  87
  88     public static final String ID = "eu.etaxonomy.taxeditor.editor.view.derivate.DerivateView"; //$NON-NLS-1$
  89     public static final String INPUT_ID = ID+".editorInput"; //$NON-NLS-1$
  90
  91     public static final String YOU_NEED_TO_SAVE_BEFORE_PERFORMING_THIS_ACTION = Messages.DerivateView_YOU_NEED_TO_SAVE;
  92     public static final String VIEW_HAS_UNSAVED_CHANGES = Messages.DerivateView_UNSAVED_CHANGES;
  93
  94     private static final List<String> SPECIMEN_INIT_STRATEGY = Arrays.asList(new String[] {
  95             "descriptions", //$NON-NLS-1$
  96             "annotations", //$NON-NLS-1$
  97             "markers", //$NON-NLS-1$
  98             "credits", //$NON-NLS-1$
  99             "extensions", //$NON-NLS-1$
 100             "rights", //$NON-NLS-1$
 101             "sources", //$NON-NLS-1$
 102             "derivationEvents.derivatives.annotations", //$NON-NLS-1$
 103             "derivationEvents.derivatives.markers", //$NON-NLS-1$
 104             "derivationEvents.derivatives.credits", //$NON-NLS-1$
 105             "derivationEvents.derivatives.extensions", //$NON-NLS-1$
 106             "derivationEvents.derivatives.rights", //$NON-NLS-1$
 107             "derivationEvents.derivatives.sources" //$NON-NLS-1$
 108     });
 109
 110         private static final int WARN_THRESHOLD = 200;
 111
 112
 113         private ConversationHolder conversation;
 114
 115         private TreeViewer viewer;
 116
 117     private final int dndOperations = DND.DROP_MOVE;
 118
 119     private DerivateLabelProvider labelProvider;
 120
 121     private DerivateContentProvider contentProvider;
 122
 123     private DerivateSearchCompositeController derivateSearchCompositeController;
 124
 125     /**
 126      * A map with keys being the derivative entities belonging to the {@link UUID}s passed to the constructor
 127      * and values being the root elements of the hierarchy (may be the same objects as the derivative entities)
 128      */
 129     private Map<SpecimenOrObservationBase<?>, SpecimenOrObservationBase<?>> derivateToRootEntityMap;
 130
 131     /**
 132      * The set of root elements
 133      */
 134     private Set<SpecimenOrObservationBase<?>> rootElements;
 135
 136     private ICdmEntitySession cdmEntitySession;
 137
 138     /**
 139      * <code>true</code> if this view is listening to selection  changes
 140      */
 141     private boolean listenToSelectionChange;
 142
 143     private Taxon selectedTaxon;
 144
 145     @Inject
 146     private ESelectionService selService;
 147
 148     @Inject
 149     private MDirtyable dirty;
 150
 151     @Inject
 152     private EPartService partService;
 153
 154     private ISelectionChangedListener selectionChangedListener;
 155
 156     /**
 157      * Default constructor
 158      */
 159     @Inject
 160     public DerivateView() {
 161     }
 162
 163     /**
 164      * {@inheritDoc}
 165      */
 166     public void init(DerivateViewEditorInput editorInput){
 167         this.derivateToRootEntityMap = new HashMap<SpecimenOrObservationBase<?>, SpecimenOrObservationBase<?>>();
 168         this.rootElements = new HashSet<SpecimenOrObservationBase<?>>();
 169
 170         //init tree
 171         Collection<UUID> derivativeUuids = editorInput.getDerivativeUuids();
 172         checkWarnThreshold(derivativeUuids);
 173         updateRootEntities(derivativeUuids);
 174         //set taxon filter
 175         derivateSearchCompositeController.setTaxonFilter(editorInput.getTaxonUuid());
 176         //reset status bar
 177         //TODO e4
 178 //        getEditorSite().getActionBars().getStatusLineManager().setMessage(""); //$NON-NLS-1$
 179     }
 180
 181     @PostConstruct
 182     public void createPartControl(Composite parent, EMenuService menuService) {
 183         if (CdmStore.isActive()){
 184             if(conversation == null){
 185                 conversation = CdmStore.createConversation();
 186             }
 187             if(cdmEntitySession!=null){
 188                 cdmEntitySession = CdmStore.getCurrentSessionManager().newSession(this, true);
 189             }
 190         }
 191         else{
 192             return;
 193         }
 194         //listen to context changes
 195         CdmStore.getContextManager().addContextListener(this);
 196
 197         parent.setLayout(new GridLayout());
 198
 199         //---search and filter---
 200         derivateSearchCompositeController = new DerivateSearchCompositeController(parent, this);
 201         GridData gridDataSearchBar = new GridData();
 202         gridDataSearchBar.horizontalAlignment = GridData.FILL;
 203         gridDataSearchBar.grabExcessHorizontalSpace = true;
 204         derivateSearchCompositeController.setLayoutData(gridDataSearchBar);
 205         derivateSearchCompositeController.setEnabled(CdmStore.isActive());
 206
 207         //---tree viewer---
 208         viewer = new TreeViewer(new Tree(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION));
 209         GridData gridDataTree = new GridData();
 210         gridDataTree.horizontalAlignment = GridData.FILL;
 211         gridDataTree.verticalAlignment = GridData.FILL;
 212         gridDataTree.grabExcessVerticalSpace = true;
 213         gridDataTree.grabExcessHorizontalSpace = true;
 214         viewer.getTree().setLayoutData(gridDataTree);
 215         contentProvider = new DerivateContentProvider();
 216         viewer.setContentProvider(contentProvider);
 217         labelProvider = new DerivateLabelProvider();
 218         labelProvider.setConversation(conversation);
 219         viewer.setLabelProvider(labelProvider);
 220         viewer.setAutoExpandLevel(AbstractTreeViewer.ALL_LEVELS);
 221         viewer.getTree().setEnabled(CdmStore.isActive());
 222
 223         //propagate selection
 224         selectionChangedListener = (event -> selService.setSelection(AbstractUtility.getElementsFromSelectionChangedEvent(event)));
 225         viewer.addSelectionChangedListener(selectionChangedListener);
 226
 227         //create context menu
 228         menuService.registerContextMenu(viewer.getControl(), "eu.etaxonomy.taxeditor.editor.popupmenu.specimeneditor");
 229
 230         //add drag'n'drop support
 231         Transfer[] transfers = new Transfer[] {LocalSelectionTransfer.getTransfer(),};
 232         viewer.addDragSupport(dndOperations, transfers, new DerivateDragListener(this));
 233         viewer.addDropSupport(dndOperations, transfers, new DerivateDropListener(this));
 234     }
 235
 236     public void updateRootEntities() {
 237         updateRootEntities((Collection)null);
 238     }
 239
 240     public void updateRootEntities(Collection<UUID> derivativeUuids) {
 241         if(conversation!=null){
 242             if (!conversation.isBound()) {
 243                 conversation.bind();
 244             }
 245             /*
 246              * If the active session is not the session of the Derivative Editor
 247              * then we will save the active session for later, bind temporarily
 248              * to our session and rebind to the original session when we are
 249              * done. This happens e.g. if a selection change happens in the
 250              * taxon editor and "Link with editor" is enabled. The selection
 251              * change event and thus the loading in updateRootEntities() happens
 252              * in the session of the taxon editor.
 253              */
 254             ICdmEntitySession previousCdmEntitySession = CdmStore.getCurrentSessionManager().getActiveSession();
 255             if(cdmEntitySession != null) {
 256                 cdmEntitySession.bind();
 257             }
 258
 259             List<SpecimenOrObservationBase> derivates = null;
 260             if(derivativeUuids!=null){
 261                 this.derivateToRootEntityMap = new HashMap<SpecimenOrObservationBase<?>, SpecimenOrObservationBase<?>>();
 262                 this.rootElements = new HashSet<SpecimenOrObservationBase<?>>();
 263                 derivates = CdmStore.getService(IOccurrenceService.class).load(new ArrayList(derivativeUuids), SPECIMEN_INIT_STRATEGY);
 264             }
 265             updateRootEntities(derivates);
 266             previousCdmEntitySession.bind();
 267         }
 268     }
 269
 270
 271     public void updateRootEntities(List<SpecimenOrObservationBase> derivates) {
 272         if(derivates!=null){
 273             this.derivateToRootEntityMap = new HashMap<SpecimenOrObservationBase<?>, SpecimenOrObservationBase<?>>();
 274             this.rootElements = new HashSet<SpecimenOrObservationBase<?>>();
 275             for (SpecimenOrObservationBase derivate : derivates) {
 276
 277                 if(derivate instanceof FieldUnit){
 278                     derivateToRootEntityMap.put(derivate, derivate);
 279                 }
 280                 else {
 281                     SpecimenOrObservationBase<?> topMostDerivate = EditorUtil.getTopMostDerivate(derivate);
 282                     if(topMostDerivate!=null){
 283                         derivateToRootEntityMap.put(derivate, topMostDerivate);
 284                     }
 285                     else{
 286                         derivateToRootEntityMap.put(derivate, derivate);
 287                     }
 288                 }
 289             }
 290             for (SpecimenOrObservationBase<?> specimen : derivateToRootEntityMap.values()) {
 291                 rootElements.add(specimen);
 292             }
 293         }
 294         labelProvider.updateLabelCache(rootElements);
 295         viewer.setInput(rootElements);
 296
 297         //TODO e4
 298         //            getEditorSite().getActionBars().getStatusLineManager().setMessage(String.format(Messages.DerivateView_CNT_DERIVATIVES_FOUND, rootElements.size()));
 299
 300         //set selection to derivatives if the filter criteria
 301         //taxon assignment or derivative type are set
 302         if(derivates!=null && !derivateSearchCompositeController.isDefaultSearch()){
 303             List<TreeNode> nodesToSelect = new ArrayList<TreeNode>();
 304             for (SpecimenOrObservationBase specimenOrObservationBase : derivates) {
 305                 nodesToSelect.add(new TreeNode(specimenOrObservationBase));
 306             }
 307             setSelection(new StructuredSelection(nodesToSelect));
 308         }
 309         else{
 310             setSelection(null);
 311         }
 312     }
 313
 314     private void setSelection(StructuredSelection selection){
 315         viewer.removeSelectionChangedListener(selectionChangedListener);
 316         viewer.setSelection(selection);
 317         viewer.addSelectionChangedListener(selectionChangedListener);
 318     }
 319
 320     public void updateLabelCache(){
 321         labelProvider.updateLabelCache(rootElements);
 322     }
 323
 324     @Persist
 325     @Override
 326     public void save(IProgressMonitor monitor) {
 327         String taskName = Messages.DerivateView_SAVING_HIERARCHY;
 328         monitor.beginTask(taskName, 3);
 329         if (!conversation.isBound()) {
 330             conversation.bind();
 331         }
 332         monitor.worked(1);
 333
 334         // commit the conversation and start a new transaction immediately
 335         conversation.commit(true);
 336
 337         CdmStore.getService(IOccurrenceService.class).merge(new ArrayList<SpecimenOrObservationBase>(rootElements), true);
 338
 339         monitor.worked(1);
 340
 341         this.setDirty(false);
 342         monitor.worked(1);
 343         monitor.done();
 344         dirty.setDirty(false);
 345         refreshTree();
 346     }
 347
 348     /**
 349      * @param isDirty the isDirty to set
 350      */
 351     public void setDirty(boolean isDirty) {
 352         dirty.setDirty(isDirty);
 353     }
 354
 355     @Focus
 356     public void setFocus() {
 357         //make sure to bind again if maybe in another view the conversation was unbound
 358         if(conversation!=null && !conversation.isBound()){
 359             conversation.bind();
 360         }
 361         if(cdmEntitySession != null) {
 362             cdmEntitySession.bind();
 363         }
 364         if(derivateSearchCompositeController!=null) {
 365             derivateSearchCompositeController.setFocusOnSearchField();
 366         }
 367     }
 368
 369     @Override
 370     public void update(CdmDataChangeMap changeEvents) {
 371     }
 372
 373     @Override
 374     public ConversationHolder getConversationHolder() {
 375         return conversation;
 376     }
 377
 378     @Override
 379     public void changed(Object element) {
 380         setDirty(true);
 381         //firePropertyChange(IEditorPart.PROP_DIRTY);
 382         viewer.update(new TreeNode(element), null);
 383     }
 384
 385     @Override
 386     public void forceDirty() {
 387         changed(null);
 388     }
 389
 390     @Override
 391     public Map<Object, List<String>> getPropertyPathsMap() {
 392         List<String> specimenPropertyPaths = Arrays.asList(new String[] {
 393                 "descriptions", //$NON-NLS-1$
 394                 "derivationEvents.derivates", //$NON-NLS-1$
 395                 "annotations", //$NON-NLS-1$
 396                 "markers", //$NON-NLS-1$
 397                 "credits", //$NON-NLS-1$
 398                 "extensions", //$NON-NLS-1$
 399                 "rights", //$NON-NLS-1$
 400                 "sources" //$NON-NLS-1$
 401         });
 402         Map<Object, List<String>> specimenPropertyPathMap =
 403                 new HashMap<Object, List<String>>();
 404         specimenPropertyPathMap.put(SpecimenOrObservationBase.class,specimenPropertyPaths);
 405         return specimenPropertyPathMap;
 406     }
 407
 408     /**
 409      * Refreshes the derivate hierarchy tree and expands the tree
 410      * to show and select the given object.
 411      *
 412      * @param expandTo the object to which the tree should be expanded
 413      */
 414     public void refreshTree(Object expandTo){
 415         refreshTree();
 416         TreeSelection selection = (TreeSelection) viewer.getSelection();
 417         viewer.expandToLevel(selection.getFirstElement(), 1);
 418         viewer.setSelection(new StructuredSelection(new TreeNode(expandTo)));
 419     }
 420
 421     /**
 422      * Refreshes the derivate hierarchy tree
 423      */
 424     public void refreshTree(){
 425         if(!viewer.getTree().isDisposed()){
 426                 viewer.refresh();
 427         }
 428     }
 429
 430     //FIXME:Remoting hack to make this work for remoting
 431     //This should actually be resolved using remoting post operations
 432     public void remove(Object obj) {
 433         if (obj instanceof TreeNode){
 434             obj = ((TreeNode)obj).getValue();
 435         }
 436         rootElements.remove(obj);
 437         Object o = this.derivateToRootEntityMap.remove(obj);
 438         viewer.setInput(rootElements);
 439     }
 440
 441     /**
 442      * @return a set of {@link SingleRead}s that have multiple parents
 443      */
 444     public Set<SingleRead> getMultiLinkSingleReads() {
 445         return DerivateLabelProvider.getMultiLinkSingleReads();
 446     }
 447
 448     public Object getSelectionInput() {
 449         return selectedTaxon;
 450     }
 451
 452     public DerivateLabelProvider getLabelProvider() {
 453         return labelProvider;
 454     }
 455
 456     @Override
 457     public boolean postOperation(CdmBase objectAffectedByOperation) {
 458         refreshTree();
 459         if(objectAffectedByOperation!=null){
 460             changed(objectAffectedByOperation);
 461         }
 462         return true;
 463     }
 464
 465     @Override
 466     public boolean onComplete() {
 467         return true;
 468     }
 469
 470
 471     @Override
 472     public boolean canAttachMedia() {
 473         return true;
 474     }
 475
 476     public void addFieldUnit(FieldUnit fieldUnit) {
 477         rootElements.add(fieldUnit);
 478         derivateToRootEntityMap.put(fieldUnit, fieldUnit);
 479     }
 480
 481     @Override
 482     public ICdmEntitySession getCdmEntitySession() {
 483         return cdmEntitySession;
 484     }
 485
 486     @PreDestroy
 487     public void dispose() {
 488         if(conversation!=null){
 489             conversation.close();
 490         }
 491         if(cdmEntitySession != null) {
 492             cdmEntitySession.dispose();
 493         }
 494     }
 495
 496
 497     @Inject
 498     @Optional
 499     public void selectionChanged(@Optional @Named(IServiceConstants.ACTIVE_SELECTION) ISelection selection,
 500             @Named(IServiceConstants.ACTIVE_PART) MPart activePart, MPart thisPart)
 501     {
 502         if(activePart == thisPart || viewer==null){
 503             return;
 504         }
 505         if(viewer.getTree().isDisposed()){
 506             return;
 507         }
 508         if(listenToSelectionChange){
 509             selectedTaxon = null;
 510             if(activePart instanceof MultiPageTaxonEditor){
 511                 selectedTaxon = ((MultiPageTaxonEditor) activePart).getTaxon();
 512             }
 513             else if(selection instanceof IStructuredSelection){
 514                 Object selectedElement = ((IStructuredSelection) selection).getFirstElement();
 515                 if(selectedElement instanceof CdmBase){
 516                     if(((CdmBase) selectedElement).isInstanceOf(TaxonNode.class)){
 517                         selectedTaxon = HibernateProxyHelper.deproxy(selectedElement, TaxonNode.class).getTaxon();
 518                     }
 519                     else if(((CdmBase) selectedElement).isInstanceOf(Taxon.class)){
 520                         selectedTaxon = HibernateProxyHelper.deproxy(selectedElement, Taxon.class);
 521                     }
 522                 }
 523             }
 524             if(selectedTaxon!=null){
 525                 Collection<SpecimenOrObservationBase> fieldUnits = CdmStore.getService(IOccurrenceService.class).listFieldUnitsByAssociatedTaxon(selectedTaxon, null, null);
 526                 Collection<UUID> uuids = new HashSet<UUID>();
 527                 for (SpecimenOrObservationBase specimenOrObservationBase : fieldUnits) {
 528                     uuids.add(specimenOrObservationBase.getUuid());
 529                 }
 530                 checkWarnThreshold(uuids);
 531                 updateRootEntities(uuids);
 532
 533                 thisPart.setLabel(SPECIMEN_EDITOR+": " + selectedTaxon.getName()); //$NON-NLS-1$
 534             }
 535             else{
 536                 updateRootEntities((Collection<UUID>)Collections.EMPTY_LIST);
 537             }
 538         }
 539     }
 540
 541         private void checkWarnThreshold(Collection<UUID> uuids) {
 542                 if(uuids!=null && uuids.size()>WARN_THRESHOLD){
 543                         MessagingUtils.warningDialog(Messages.DerivateView_PERF_WARNING, this.getClass(), String.format(Messages.DerivateView_PERF_WARNING_MESSAGE, uuids.size()));
 544                         uuids.clear();
 545                 }
 546         }
 547
 548     public TreeViewer getViewer() {
 549         return viewer;
 550     }
 551
 552     /**
 553      * {@inheritDoc}
 554      */
 555     @Override
 556     public List<SpecimenOrObservationBase<?>> getRootEntities() {
 557         return new ArrayList<SpecimenOrObservationBase<?>>(rootElements);
 558     }
 559
 560     public void toggleListenToSelectionChange(MPart part) {
 561         listenToSelectionChange = !listenToSelectionChange;
 562         derivateSearchCompositeController.setEnabled(!listenToSelectionChange);
 563         if(!listenToSelectionChange){
 564             selectedTaxon = null;
 565             part.setLabel(SPECIMEN_EDITOR);
 566         }
 567         else if(selectedTaxon==null){
 568             part.setLabel(SPECIMEN_EDITOR+Messages.DerivateView_NO_TAXON_SELECTED);
 569         }
 570     }
 571
 572     public boolean isListenToSelectionChange(){
 573         return listenToSelectionChange;
 574     }
 575
 576     /**
 577      * {@inheritDoc}
 578      */
 579     @Override
 580     public void contextAboutToStop(IMemento memento, IProgressMonitor monitor) {
 581     }
 582
 583     /**
 584      * {@inheritDoc}
 585      */
 586     @Override
 587     public void contextStop(IMemento memento, IProgressMonitor monitor) {
 588         derivateSearchCompositeController.setEnabled(false);
 589         if(!viewer.getTree().isDisposed()) {
 590             viewer.getTree().setEnabled(false);
 591             viewer.setInput(null);
 592         }
 593     }
 594
 595     /**
 596      * {@inheritDoc}
 597      */
 598     @Override
 599     public void contextStart(IMemento memento, IProgressMonitor monitor) {
 600         derivateSearchCompositeController.setEnabled(!listenToSelectionChange);
 601         if(!viewer.getTree().isDisposed()){
 602             viewer.getTree().setEnabled(true);
 603         }
 604         refreshTree();
 605     }
 606
 607     /**
 608      * {@inheritDoc}
 609      */
 610     @Override
 611     public void contextRefresh(IProgressMonitor monitor) {
 612     }
 613
 614     /**
 615      * {@inheritDoc}
 616      */
 617     @Override
 618     public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {
 619     }
 620
 621
 622     public boolean isDirty() {
 623         return dirty.isDirty();
 624     }
 625
 626 }