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