/*
 * Copyright (c) 2007-2013, 2015, 2016 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Eike Stepper - initial API and implementation
 *    Victor Roldan Betancort - maintenance
 *    Christian W. Damus (CEA LIST) - bug 419805, bug 399306
 */
package org.eclipse.emf.cdo.ui;

import org.eclipse.emf.cdo.CDOObject;
import org.eclipse.emf.cdo.CDOState;
import org.eclipse.emf.cdo.common.CDOCommonRepository.State;
import org.eclipse.emf.cdo.common.CDOCommonView;
import org.eclipse.emf.cdo.common.branch.CDOBranch;
import org.eclipse.emf.cdo.common.branch.CDOBranchManager;
import org.eclipse.emf.cdo.common.branch.CDOBranchPoint;
import org.eclipse.emf.cdo.common.commit.CDOCommitInfo;
import org.eclipse.emf.cdo.common.model.CDOPackageRegistry;
import org.eclipse.emf.cdo.common.model.CDOPackageTypeRegistry;
import org.eclipse.emf.cdo.common.model.CDOPackageUnit.Type;
import org.eclipse.emf.cdo.common.security.CDOPermission;
import org.eclipse.emf.cdo.common.util.CDOCommonUtil;
import org.eclipse.emf.cdo.eresource.CDOBinaryResource;
import org.eclipse.emf.cdo.eresource.CDOResource;
import org.eclipse.emf.cdo.eresource.CDOResourceFolder;
import org.eclipse.emf.cdo.eresource.CDOResourceLeaf;
import org.eclipse.emf.cdo.eresource.CDOResourceNode;
import org.eclipse.emf.cdo.eresource.CDOTextResource;
import org.eclipse.emf.cdo.internal.ui.actions.ChangePasswordAction;
import org.eclipse.emf.cdo.internal.ui.actions.CloseSessionAction;
import org.eclipse.emf.cdo.internal.ui.actions.CloseViewAction;
import org.eclipse.emf.cdo.internal.ui.actions.CommitTransactionAction;
import org.eclipse.emf.cdo.internal.ui.actions.CreateBranchAction;
import org.eclipse.emf.cdo.internal.ui.actions.DisableViewDurabilityAction;
import org.eclipse.emf.cdo.internal.ui.actions.EnableViewDurabilityAction;
import org.eclipse.emf.cdo.internal.ui.actions.ExportResourceAction;
import org.eclipse.emf.cdo.internal.ui.actions.ImportResourceAction;
import org.eclipse.emf.cdo.internal.ui.actions.LoadResourceAction;
import org.eclipse.emf.cdo.internal.ui.actions.ManagePackagesAction;
import org.eclipse.emf.cdo.internal.ui.actions.MergeBranchPointAction;
import org.eclipse.emf.cdo.internal.ui.actions.MergeConflictsAction;
import org.eclipse.emf.cdo.internal.ui.actions.NewResourceNodeAction;
import org.eclipse.emf.cdo.internal.ui.actions.NewTopLevelResourceNodeAction;
import org.eclipse.emf.cdo.internal.ui.actions.OpenAuditAction;
import org.eclipse.emf.cdo.internal.ui.actions.OpenDurableViewAction;
import org.eclipse.emf.cdo.internal.ui.actions.OpenResourceEditorAction;
import org.eclipse.emf.cdo.internal.ui.actions.OpenTransactionAction;
import org.eclipse.emf.cdo.internal.ui.actions.OpenViewAction;
import org.eclipse.emf.cdo.internal.ui.actions.RegisterSinglePackageAction;
import org.eclipse.emf.cdo.internal.ui.actions.RollbackTransactionAction;
import org.eclipse.emf.cdo.internal.ui.actions.SwitchTargetAction;
import org.eclipse.emf.cdo.internal.ui.messages.Messages;
import org.eclipse.emf.cdo.session.CDORepositoryInfo;
import org.eclipse.emf.cdo.session.CDOSession;
import org.eclipse.emf.cdo.session.CDOSessionInvalidationEvent;
import org.eclipse.emf.cdo.transaction.CDOTransaction;
import org.eclipse.emf.cdo.transfer.CDOTransferElement;
import org.eclipse.emf.cdo.ui.shared.SharedIcons;
import org.eclipse.emf.cdo.util.CDOUtil;
import org.eclipse.emf.cdo.view.CDOObjectHandler;
import org.eclipse.emf.cdo.view.CDOView;
import org.eclipse.emf.cdo.view.CDOViewLocksChangedEvent;
import org.eclipse.emf.cdo.view.CDOViewTargetChangedEvent;

import org.eclipse.net4j.util.StringUtil;
import org.eclipse.net4j.util.container.IContainer;
import org.eclipse.net4j.util.container.IContainerDelta;
import org.eclipse.net4j.util.container.IContainerEvent;
import org.eclipse.net4j.util.event.IEvent;
import org.eclipse.net4j.util.event.IListener;
import org.eclipse.net4j.util.event.INotifier;
import org.eclipse.net4j.util.lifecycle.ILifecycle;
import org.eclipse.net4j.util.lifecycle.ILifecycleEvent;
import org.eclipse.net4j.util.ui.views.ContainerItemProvider;
import org.eclipse.net4j.util.ui.views.IElementFilter;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;

import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.resource.LocalResourceManager;
import org.eclipse.jface.resource.ResourceManager;
import org.eclipse.jface.viewers.ITreeSelection;
import org.eclipse.jface.viewers.LabelProviderChangedEvent;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.ui.IEditorDescriptor;
import org.eclipse.ui.IEditorRegistry;
import org.eclipse.ui.IPropertyListener;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PlatformUI;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Implements multiple functionality related with UI representation of basic CDO concepts on
 * {@link org.eclipse.jface.viewers.TreeViewer TreeViewer}-based editors and views.
 * <p>
 * For instance, behaves as {@link org.eclipse.jface.viewers.IContentProvider content} and
 * {@link org.eclipse.jface.viewers.ILabelProvider label} provider for concepts such as {@link CDOSession},
 * {@link CDOView}, {@link CDOResource} and {@link CDOResourceFolder}. It also providers common context menu action over
 * those elements.
 *
 * @author Eike Stepper
 * @see org.eclipse.jface.viewers.IContentProvider
 * @see org.eclipse.jface.viewers.ILabelProvider
 */
public class CDOItemProvider extends ContainerItemProvider<IContainer<Object>>
{
  private static final IEditorRegistry EDITOR_REGISTRY = PlatformUI.getWorkbench().getEditorRegistry();

  private IPropertyListener editorRegistryListener;

  private final ElementListener elementListener = new ElementListener();

  private ResourceManager resourceManager;

  private IWorkbenchPage page;

  private boolean mergeMainBranchWithSession;

  public CDOItemProvider(IWorkbenchPage page, IElementFilter rootElementFilter)
  {
    super(rootElementFilter);
    this.page = page;
  }

  public CDOItemProvider(IWorkbenchPage page)
  {
    this(page, null);
  }

  @Override
  public void dispose()
  {
    elementListener.dispose();

    if (editorRegistryListener != null)
    {
      EDITOR_REGISTRY.removePropertyListener(editorRegistryListener);
      resourceManager = null;
    }

    if (resourceManager != null)
    {
      resourceManager.dispose();
      resourceManager = null;
    }

    super.dispose();
  }

  /**
   * @since 4.4
   */
  public boolean useFullPath(Object object)
  {
    return false;
  }

  /**
   * @since 4.2
   */
  public boolean isMergeMainBranchWithSession()
  {
    return mergeMainBranchWithSession;
  }

  /**
   * @since 4.2
   */
  public void setMergeMainBranchWithSession(boolean mergeMainBranchWithSession)
  {
    if (this.mergeMainBranchWithSession != mergeMainBranchWithSession)
    {
      this.mergeMainBranchWithSession = mergeMainBranchWithSession;
      refreshViewer(true);
    }
  }

  @Override
  public Object[] getChildren(Object element)
  {
    if (element instanceof CDOBranchManager)
    {
      return new Object[] { ((CDOBranchManager)element).getMainBranch() };
    }

    if (element instanceof CDOBranch)
    {
      return getChildren((CDOBranch)element);
    }

    if (mergeMainBranchWithSession && element instanceof CDOSession)
    {
      return getChildren(((CDOSession)element).getBranchManager().getMainBranch());
    }

    if (element instanceof CDOResourceFolder)
    {
      CDOResourceFolder folder = (CDOResourceFolder)element;
      if (folder.cdoPermission() == CDOPermission.NONE)
      {
        return NO_ELEMENTS;
      }

      return folder.getNodes().toArray();
    }

    return super.getChildren(element);
  }

  /**
   * @since 4.2
   */
  protected Object[] getChildren(CDOBranch branch)
  {
    CDOBranch[] branches = branch.getBranches();
    if (!mergeMainBranchWithSession)
    {
      return branch.getBranches();
    }

    Object[] views = getViews(branch);

    if (views.length == 0)
    {
      return branches;
    }

    if (branches.length == 0)
    {
      return views;
    }

    Object[] children = new Object[branches.length + views.length];
    System.arraycopy(branches, 0, children, 0, branches.length);
    System.arraycopy(views, 0, children, branches.length, views.length);
    return children;
  }

  private Object[] getViews(CDOBranch branch)
  {
    CDOSession session = CDOUtil.getSession(branch);
    if (session != null)
    {
      return session.getViews(branch);
    }

    return NO_ELEMENTS;
  }

  @Override
  public boolean hasChildren(Object element)
  {
    if (element instanceof CDOBranchManager)
    {
      return true; // Main branch always exists
    }

    if (element instanceof CDOBranch)
    {
      return hasChildren((CDOBranch)element);
    }

    if (element instanceof CDOSession)
    {
      if (mergeMainBranchWithSession)
      {
        return hasChildren(((CDOSession)element).getBranchManager().getMainBranch());
      }
    }

    if (element instanceof CDOResourceFolder)
    {
      CDOResourceFolder folder = (CDOResourceFolder)element;
      if (folder.cdoPermission() == CDOPermission.NONE)
      {
        return false;
      }

      return !folder.getNodes().isEmpty();
    }

    return super.hasChildren(element);
  }

  /**
   * @since 4.2
   */
  protected boolean hasChildren(CDOBranch branch)
  {
    if (!branch.isEmpty())
    {
      return true;
    }

    Object[] views = getViews(branch);
    return views.length != 0;
  }

  @Override
  public Object getParent(Object element)
  {
    if (element instanceof CDOBranch)
    {
      CDOBranch branch = (CDOBranch)element;
      if (branch.isMainBranch())
      {
        if (mergeMainBranchWithSession)
        {
          return CDOUtil.getSession(branch);
        }

        return branch.getBranchManager();
      }

      return branch.getBase().getBranch();
    }

    if (element instanceof CDOResourceNode)
    {
      CDOResourceNode node = (CDOResourceNode)element;
      CDOResourceNode parent = (CDOResourceNode)node.eContainer();
      if (parent == null || parent.isRoot())
      {
        return node.cdoView();
      }

      return parent;
    }

    if (element instanceof CDOView)
    {
      CDOView view = (CDOView)element;
      CDOBranch branch = view.getBranch();
      if (branch.isMainBranch() || !mergeMainBranchWithSession)
      {
        return view.getSession();
      }

      return branch;
    }

    return super.getParent(element);
  }

  @Override
  public String getText(Object obj)
  {
    if (obj instanceof CDOCommonView)
    {
      // Don't treat views as branch points (see below).
      return super.getText(obj);
    }

    if (obj instanceof CDOBranch)
    {
      if (useFullPath(obj))
      {
        return ((CDOBranch)obj).getPathName();
      }

      return ((CDOBranch)obj).getName();
    }

    if (obj instanceof CDOBranchPoint)
    {
      CDOBranchPoint branchPoint = (CDOBranchPoint)obj;
      String result = getText(branchPoint.getBranch());

      long timeStamp = branchPoint.getTimeStamp();
      if (timeStamp != CDOBranchPoint.UNSPECIFIED_DATE)
      {
        result += " [" + CDOCommonUtil.formatTimeStamp(timeStamp) + "]";
      }

      return result;
    }

    if (obj instanceof CDOResourceNode)
    {
      if (useFullPath(obj))
      {
        return ((CDOResourceNode)obj).getPath();
      }

      return ((CDOResourceNode)obj).getName();
    }

    return super.getText(obj);
  }

  @Override
  public Image getImage(Object obj)
  {
    if (obj instanceof CDOSession)
    {
      CDOSession session = (CDOSession)obj;
      State state = session.getRepositoryInfo().getState();
      switch (state)
      {
      case ONLINE:
        return SharedIcons.getImage(SharedIcons.OBJ_SESSION);
      case SYNCING:
        return SharedIcons.getImage(SharedIcons.OBJ_SESSION_SYNCING);
      case OFFLINE:
        return SharedIcons.getImage(SharedIcons.OBJ_SESSION_OFFLINE);
      }
    }

    if (obj instanceof CDOView)
    {
      CDOView view = (CDOView)obj;
      return getViewImage(view);
    }

    if (obj instanceof CDOCommitInfo)
    {
      return SharedIcons.getImage(SharedIcons.OBJ_COMMIT);
    }

    if (obj instanceof CDOBranch)
    {
      return SharedIcons.getImage(SharedIcons.OBJ_BRANCH);
    }

    if (obj instanceof CDOBranchPoint)
    {
      CDOBranchPoint branchPoint = (CDOBranchPoint)obj;
      if (branchPoint.getTimeStamp() == CDOBranchPoint.UNSPECIFIED_DATE)
      {
        return SharedIcons.getImage(SharedIcons.OBJ_BRANCH);
      }

      return SharedIcons.getImage(SharedIcons.OBJ_BRANCH_POINT);
    }

    if (obj instanceof CDOResourceFolder)
    {
      return SharedIcons.getImage(SharedIcons.OBJ_RESOURCE_FOLDER);
    }

    if (obj instanceof CDOResourceLeaf)
    {
      String name = ((CDOResourceLeaf)obj).getName();
      IEditorDescriptor editorDescriptor = EDITOR_REGISTRY.getDefaultEditor(name);
      if (editorDescriptor != null && !CDOEditorUtil.TEXT_EDITOR_ID.equals(editorDescriptor.getId()))
      {
        Image image = getWorkbenchImage(name);
        if (image != null)
        {
          return image;
        }
      }

      if (obj instanceof CDOResource)
      {
        return SharedIcons.getImage(SharedIcons.OBJ_RESOURCE);
      }

      if (obj instanceof CDOTextResource)
      {
        return SharedIcons.getImage(SharedIcons.OBJ_TEXT_RESOURCE);
      }

      if (obj instanceof CDOBinaryResource)
      {
        return SharedIcons.getImage(SharedIcons.OBJ_BINARY_RESOURCE);
      }
    }

    return super.getImage(obj);
  }

  /**
   * @since 4.2
   */
  protected Image getWorkbenchImage(String name)
  {
    ImageDescriptor imageDescriptor = EDITOR_REGISTRY.getImageDescriptor(name);
    if (imageDescriptor != null)
    {
      if (editorRegistryListener == null)
      {
        editorRegistryListener = new EditorRegistryListener(this);
        EDITOR_REGISTRY.addPropertyListener(editorRegistryListener);
      }

      ResourceManager resourceManager = getResourceManager();
      return (Image)resourceManager.get(imageDescriptor);
    }

    return null;
  }

  /**
   * @since 4.2
   */
  protected ResourceManager getResourceManager()
  {
    if (resourceManager == null)
    {
      resourceManager = new LocalResourceManager(JFaceResources.getResources());
    }

    return resourceManager;
  }

  @Override
  public Color getForeground(Object obj)
  {
    if (obj instanceof CDOObject)
    {
      return CDOLabelProvider.getColor((CDOObject)obj);

    }
    return super.getForeground(obj);
  }

  @Override
  public Font getFont(Object obj)
  {
    if (obj instanceof CDOTransaction)
    {
      CDOTransaction transaction = (CDOTransaction)obj;
      if (transaction.isDirty())
      {
        return getBoldFont();
      }
    }

    return super.getFont(obj);
  }

  /**
   * @since 4.2
   */
  @Override
  public void fillContextMenu(IMenuManager manager, ITreeSelection selection)
  {
    if (selection.size() == 1)
    {
      Object object = selection.getFirstElement();
      if (object instanceof CDOSession)
      {
        fillSession(manager, (CDOSession)object);
      }
      else if (object instanceof CDOView)
      {
        fillView(manager, (CDOView)object);
      }
      else if (object instanceof CDOBranch)
      {
        fillBranch(manager, (CDOBranch)object);
      }
      else if (object instanceof CDOResourceNode)
      {
        fillResourceNode(manager, (CDOResourceNode)object);
      }
    }

    manager.add(new Separator());
    super.fillContextMenu(manager, selection);
  }

  /**
   * @since 4.2
   */
  public void fillSession(IMenuManager manager, CDOSession session)
  {
    manager.add(new OpenTransactionAction(page, session));
    manager.add(new OpenViewAction(page, session));
    manager.add(new OpenAuditAction(page, session));
    manager.add(new OpenDurableViewAction(page, session));
    manager.add(new Separator());
    manager.add(new ManagePackagesAction(page, session));

    MenuManager generatedManager = new MenuManager(Messages.getString("CDOItemProvider.8")); //$NON-NLS-1$
    if (fillGenerated(generatedManager, session))
    {
      manager.add(generatedManager);
    }

    if (session.getRepositoryInfo().isSupportingBranches())
    {
      manager.add(new Separator());
      fillBranch(manager, session.getBranchManager().getMainBranch());
    }

    manager.add(new Separator());

    if (!StringUtil.isEmpty(session.getUserID()))
    {
      manager.add(new ChangePasswordAction(page, session));
    }

    manager.add(new CloseSessionAction(page, session));
  }

  /**
   * @since 4.2
   */
  public boolean fillGenerated(MenuManager manager, CDOSession session)
  {
    List<String> registeredURIs = new ArrayList<String>(EPackage.Registry.INSTANCE.keySet());
    Collections.sort(registeredURIs, new Comparator<String>()
    {
      public int compare(String o1, String o2)
      {
        return o1.compareTo(o2);
      }
    });

    boolean added = false;
    CDOPackageRegistry packageRegistry = session.getPackageRegistry();
    for (String packageURI : registeredURIs)
    {
      if (!packageRegistry.containsKey(packageURI))
      {
        Type type = CDOPackageTypeRegistry.INSTANCE.lookup(packageURI);
        if (type == Type.NATIVE)
        {
          EPackage ePackage = packageRegistry.getEPackage(packageURI);
          if (ePackage == null)
          {
            ePackage = EPackage.Registry.INSTANCE.getEPackage(packageURI);
          }

          if (ePackage != null)
          {
            manager.add(new RegisterSinglePackageAction(page, session, packageURI));
            added = true;
          }
        }
      }
    }

    return added;
  }

  /**
   * @since 4.2
   */
  public void fillView(IMenuManager manager, CDOView view)
  {
    if (!view.isReadOnly())
    {
      CDOResource rootResource = view.getRootResource();
      if (rootResource.cdoPermission() == CDOPermission.WRITE)
      {
        manager.add(new NewTopLevelResourceNodeAction(this, page, view, rootResource, NewTopLevelResourceNodeAction.Type.FOLDER));
        manager.add(new NewTopLevelResourceNodeAction(this, page, view, rootResource, NewTopLevelResourceNodeAction.Type.MODEL));
        manager.add(new NewTopLevelResourceNodeAction(this, page, view, rootResource, NewTopLevelResourceNodeAction.Type.TEXT));
        manager.add(new NewTopLevelResourceNodeAction(this, page, view, rootResource, NewTopLevelResourceNodeAction.Type.BINARY));
      }
    }

    manager.add(new Separator());
    manager.add(new LoadResourceAction(page, view));
    manager.add(new ExportResourceAction(page, view));

    if (!view.isReadOnly())
    {
      manager.add(new ImportResourceAction(page, view));
      manager.add(new Separator());
      manager.add(new MergeConflictsAction((CDOTransaction)view));
      manager.add(new MergeBranchPointAction(page, view));
      manager.add(new CommitTransactionAction(page, view));
      manager.add(new RollbackTransactionAction(page, view));
    }

    manager.add(new Separator());

    CDORepositoryInfo repositoryInfo = view.getSession().getRepositoryInfo();
    if (view.isReadOnly() && repositoryInfo.isSupportingAudits() || repositoryInfo.isSupportingBranches())
    {
      manager.add(new SwitchTargetAction(page, view));
    }

    if (view.getDurableLockingID() == null)
    {
      manager.add(new EnableViewDurabilityAction(page, view));
    }
    else
    {
      manager.add(new DisableViewDurabilityAction(page, view));
    }

    manager.add(new Separator());
    manager.add(new CloseViewAction(page, view));
  }

  /**
   * @since 4.2
   */
  public void fillBranch(IMenuManager manager, CDOBranch branch)
  {
    manager.add(new CreateBranchAction(page, branch.getHead()));
  }

  /**
   * @since 4.4
   */
  public void fillResourceNode(IMenuManager manager, CDOResourceNode node)
  {
    if (node instanceof CDOResourceFolder)
    {
      fillResourceFolder(manager, (CDOResourceFolder)node);
    }
    else if (node instanceof CDOResourceLeaf)
    {
      fillResourceLeaf(manager, node);
    }
  }

  /**
   * @since 4.2
   */
  public void fillResourceFolder(IMenuManager manager, CDOResourceFolder folder)
  {
    if (!folder.cdoView().isReadOnly() && folder.cdoPermission() == CDOPermission.WRITE)
    {
      manager.add(new NewResourceNodeAction.Folder(page, folder));
      manager.add(new NewResourceNodeAction.Model(page, folder));
      manager.add(new NewResourceNodeAction.Binary(page, folder));
      manager.add(new NewResourceNodeAction.Text(page, folder));
    }
  }

  /**
   * @since 4.2
   */
  public void fillResourceLeaf(IMenuManager manager, Object object)
  {
    CDOEditorUtil.populateMenu(manager, (CDOResourceLeaf)object, page);

    if (object instanceof CDOResource)
    {
      fillResource(manager, (CDOResource)object);
    }
    else if (object instanceof CDOTextResource)
    {
      fillTextResource(manager, (CDOTextResource)object);
    }
    else if (object instanceof CDOBinaryResource)
    {
      fillBinaryResource(manager, (CDOBinaryResource)object);
    }
  }

  /**
   * @since 4.2
   */
  public void fillResource(IMenuManager manager, CDOResource resource)
  {
    manager.add(new OpenResourceEditorAction(page, resource));
  }

  /**
   * @since 4.2
   */
  public void fillTextResource(IMenuManager manager, CDOTextResource resource)
  {
    manager.add(new OpenResourceEditorAction(page, resource));
  }

  /**
   * @since 4.2
   */
  public void fillBinaryResource(IMenuManager manager, CDOBinaryResource resource)
  {
    manager.add(new OpenResourceEditorAction(page, resource));
  }

  @Override
  protected void elementAdded(Object element, Object parent)
  {
    super.elementAdded(element, parent);

    if (element instanceof CDOSession)
    {
      elementListener.attach((CDOSession)element);
    }
  }

  /**
   * @since 4.2
   */
  @Override
  public int compare(Viewer viewer, Object e1, Object e2)
  {
    if (e1 instanceof CDOResourceFolder)
    {
      if (e2 instanceof CDOResourceLeaf)
      {
        return -1;
      }
    }

    if (e1 instanceof CDOResourceLeaf)
    {
      if (e2 instanceof CDOResourceFolder)
      {
        return 1;
      }
    }

    return super.compare(viewer, e1, e2);
  }

  /**
   * @since 3.0
   */
  public static ImageDescriptor getViewImageDescriptor(CDOView view)
  {
    if (view.isReadOnly())
    {
      if (view.getTimeStamp() != CDOView.UNSPECIFIED_DATE)
      {
        return SharedIcons.getDescriptor(SharedIcons.OBJ_EDITOR_HISTORICAL);
      }

      return SharedIcons.getDescriptor(SharedIcons.OBJ_EDITOR_READONLY);
    }

    return SharedIcons.getDescriptor(SharedIcons.OBJ_EDITOR);
  }

  /**
   * @since 3.0
   */
  public static Image getViewImage(CDOView view)
  {
    if (view.isReadOnly())
    {
      if (view.getTimeStamp() != CDOView.UNSPECIFIED_DATE)
      {
        return SharedIcons.getImage(SharedIcons.OBJ_EDITOR_HISTORICAL);
      }

      return SharedIcons.getImage(SharedIcons.OBJ_EDITOR_READONLY);
    }

    return SharedIcons.getImage(SharedIcons.OBJ_EDITOR);
  }

  /**
   * A {@link IPropertyListener listener} on the platform's {@link IEditorRegistry editor registry} that fires {@link LabelProviderChangedEvent label events}
   * from the associated {@link #getItemProvider() item provider} when {@link CDOTransferElement element} labels need to be updated.
   *
   * @author Eike Stepper
   * @since 4.2
   */
  protected static class EditorRegistryListener implements IPropertyListener
  {
    private final CDOItemProvider itemProvider;

    public EditorRegistryListener(CDOItemProvider itemProvider)
    {
      this.itemProvider = itemProvider;
    }

    public CDOItemProvider getItemProvider()
    {
      return itemProvider;
    }

    public void propertyChanged(Object source, int propId)
    {
      if (propId == IEditorRegistry.PROP_CONTENTS)
      {
        itemProvider.fireLabelProviderChanged();
      }
    }
  }

  /**
   * @author Eike Stepper
   */
  private final class ElementListener implements IListener, CDOObjectHandler
  {
    private final Set<INotifier> notifiers = new HashSet<INotifier>();

    private boolean disposed;

    public void attach(INotifier notifier)
    {
      synchronized (notifiers)
      {
        if (!disposed)
        {
          if (notifiers.add(notifier))
          {
            if (notifier instanceof CDOSession)
            {
              CDOSession session = (CDOSession)notifier;
              for (CDOView view : session.getViews())
              {
                attachView(view);
              }

              for (CDOView view : session.getTransactions())
              {
                attachView(view);
              }

              notifier.addListener(this);
            }
            else if (notifier instanceof CDOView)
            {
              CDOView view = (CDOView)notifier;
              attachView(view);
            }
          }
        }
      }
    }

    private void attachView(CDOView view)
    {
      view.addListener(this);
      view.addObjectHandler(this);
    }

    private void detach(INotifier notifier)
    {
      notifier.removeListener(this);
      if (notifier instanceof CDOView)
      {
        CDOView view = (CDOView)notifier;
        view.removeObjectHandler(this);
      }
    }

    public void dispose()
    {
      synchronized (notifiers)
      {
        disposed = true;
        for (INotifier notifier : notifiers)
        {
          detach(notifier);
        }

        notifiers.clear();
      }
    }

    public void notifyEvent(IEvent event)
    {
      if (event instanceof ILifecycleEvent)
      {
        ILifecycleEvent e = (ILifecycleEvent)event;
        if (e.getKind() == ILifecycleEvent.Kind.DEACTIVATED)
        {
          ILifecycle notifier = e.getSource();

          synchronized (notifiers)
          {
            if (notifiers.remove(notifier))
            {
              notifier.removeListener(this);
            }
          }
        }
      }
      else if (event instanceof IContainerEvent<?>)
      {
        IContainerEvent<?> e = (IContainerEvent<?>)event;
        for (IContainerDelta<?> delta : e.getDeltas())
        {
          if (delta.getKind() == IContainerDelta.Kind.ADDED)
          {
            Object element = delta.getElement();
            if (element instanceof CDOView)
            {
              attach((CDOView)element);
            }
          }
        }
      }
      else if (event instanceof CDOSessionInvalidationEvent)
      {
        refreshViewer(true);
      }
      else if (event instanceof CDOViewTargetChangedEvent)
      {
        refreshViewer(true);
      }
      else if (event instanceof CDOViewLocksChangedEvent)
      {
        CDOViewLocksChangedEvent e = (CDOViewLocksChangedEvent)event;
        EObject[] objects = e.getAffectedObjects();
        if (objects.length != 0)
        {
          updateLabels(objects);
        }
      }
    }

    public void objectStateChanged(CDOView view, CDOObject object, CDOState oldState, CDOState newState)
    {
      updateLabels(object);
    }
  }
}