/*
 * Copyright (c) 2016 Ed Merks (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *    Ed Merks - initial API and implementation
 */
package org.eclipse.oomph.ui;

import org.eclipse.oomph.internal.ui.UIPlugin;
import org.eclipse.oomph.util.CollectionUtil;
import org.eclipse.oomph.util.OS;
import org.eclipse.oomph.util.ReflectUtil;
import org.eclipse.oomph.util.StringUtil;

import org.eclipse.emf.edit.provider.ComposedImage;
import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CTabFolder;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.ShellAdapter;
import org.eclipse.swt.events.ShellEvent;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IViewReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PerspectiveAdapter;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * A Dialog in a non-modal shell associated with a workbench window where it can be docked.
 * Generally the constructor is not used to create an instance but rather the {@link #openFor(Class, Factory, IWorkbenchWindow) open} method which maintains one instance per workbench window.
 *
 * @author Ed Merks
 */
public abstract class DockableDialog extends Dialog
{
  /**
   * @author Ed Merks
   */
  public static class Dockable
  {
    private final List<WeakReference<IAction>> actions = new ArrayList<WeakReference<IAction>>();

    private Dialog dialog;

    public Dockable(Dialog dialog)
    {
      this.dialog = dialog;
    }

    public Dialog getDialog()
    {
      return dialog;
    }

    public Shell getShell()
    {
      return dialog.getShell();
    }

    public boolean handleWorkbenchPart(IWorkbenchPart part)
    {
      return true;
    }

    /**
     * The associated action will be checked and unchecked based on the visibility of the dialog.
     */
    public void associate(IAction action)
    {
      if (!getActions().contains(action))
      {
        actions.add(new WeakReference<IAction>(action));
        action.setChecked(true);
      }
    }

    public List<IAction> getActions()
    {
      List<IAction> result = new ArrayList<IAction>();
      for (Iterator<WeakReference<IAction>> it = actions.iterator(); it.hasNext();)
      {
        WeakReference<IAction> actionReference = it.next();
        IAction referencedAction = actionReference.get();
        if (referencedAction == null)
        {
          it.remove();
        }
        else
        {
          result.add(referencedAction);
        }
      }

      return result;
    }

    public IDialogSettings getBoundsSettings()
    {
      return ReflectUtil.invokeMethod("getDialogBoundsSettings", dialog);
    }

    public int open()
    {
      return dialog.open();
    }

    public boolean close()
    {
      return dialog.close();
    }

    public void setWorkbenchPart(IWorkbenchPart part)
    {
      Shell shell = getShell();
      // If there is no support for this workbench part, hide the shell, otherwise show the shell.
      if (!handleWorkbenchPart(part))
      {
        // Only force it invisible if it isn't already invisible.
        // The use may have minimized it himself, so we don't want to mark it forced unless we make it invisible.
        if (shell.isVisible())
        {
          updateVisibility(shell, false);
        }
      }
      else if (Boolean.TRUE.equals(shell.getData("forced")))
      {
        updateVisibility(shell, true);
      }
    }
  }

  /**
   * @author Ed Merks
   */
  public interface Factory<T extends Dialog>
  {
    public T create(IWorkbenchWindow workbenchWindow);
  }

  /**
   * There can be at most one per workbench window.
   */
  private static final Map<IWorkbenchWindow, Map<Class<?>, Dockable>> DIALOGS = new HashMap<IWorkbenchWindow, Map<Class<?>, Dockable>>();

  /**
   * Remember where the dialog is docked per workbench window.
   */
  private static final Map<IWorkbenchWindow, Map<Class<?>, Set<IWorkbenchPartReference>>> DOCKED_PARTS = new HashMap<IWorkbenchWindow, Map<Class<?>, Set<IWorkbenchPartReference>>>();

  /**
   * Be sure to clean the workbench from the map when the workbench window.
   */
  private static final DisposeListener WORKBENCH_DISPOSE_LISTENER = new DisposeListener()
  {
    public void widgetDisposed(DisposeEvent e)
    {
      DIALOGS.remove(e.getSource());
      DOCKED_PARTS.remove(e.getSource());
    }
  };

  private final IWorkbenchWindow workbenchWindow;

  private final Dockable dockable = new Dockable(this)
  {
    @Override
    public boolean handleWorkbenchPart(IWorkbenchPart part)
    {
      return DockableDialog.this.handleWorkbenchPart(part);
    }
  };

  protected DockableDialog(IWorkbenchWindow workbenchWindow)
  {
    super(workbenchWindow.getShell());

    // On the Mac, you can't have an invisible minimized child shell.
    // Minimizing the child shell will minimize the parent shell.
    // On Linux, it just works very poorly.
    setShellStyle(getShellStyle() ^ SWT.APPLICATION_MODAL | SWT.MODELESS | SWT.RESIZE | SWT.MAX | (OS.INSTANCE.isWin() ? SWT.MIN : SWT.NONE));
    setBlockOnOpen(false);

    this.workbenchWindow = workbenchWindow;
  }

  public abstract boolean handleWorkbenchPart(IWorkbenchPart part);

  public Dockable getDockable()
  {
    return dockable;
  }

  public IWorkbenchWindow getWorkbenchWindow()
  {
    return workbenchWindow;
  }

  private static void updateVisibility(Shell shell, boolean visible)
  {
    if (visible)
    {
      shell.setData("forced", null);

      if (OS.INSTANCE.isWin())
      {
        shell.setMinimized(false);
      }

      shell.setVisible(true);
      shell.notifyListeners(SWT.Deiconify, new Event());
    }
    else
    {
      shell.setData("forced", true);

      shell.setVisible(false);
      if (OS.INSTANCE.isWin())
      {
        shell.setMinimized(true);
      }

      shell.notifyListeners(SWT.Iconify, new Event());
    }
  }

  private static Image[] getDockedImages(Image[] images)
  {
    Image[] dockedImages = new Image[images.length];
    for (int i = 0, length = images.length; i < length; ++i)
    {
      dockedImages[i] = getDockedImage(images[i]);
    }

    return dockedImages;
  }

  private static Image getDockedImage(Image image)
  {
    if (image == null)
    {
      return null;
    }

    List<Image> images = new ArrayList<Image>();
    images.add(image);
    images.add(UIPlugin.INSTANCE.getSWTImage("docked_overlay"));
    return ExtendedImageRegistry.INSTANCE.getImage(new DockedOverlayImage(images));
  }

  /**
   * @author Ed Merks
   */
  private static class DockedOverlayImage extends ComposedImage
  {
    private DockedOverlayImage(Collection<?> images)
    {
      super(images);
    }

    @Override
    public List<Point> getDrawPoints(Size size)
    {
      List<Point> result = new ArrayList<Point>();
      result.add(new Point());
      Point overlay = new Point();
      overlay.x = size.width - 7;
      result.add(overlay);
      return result;
    }
  }

  /**
   * Return the instance for this workbench window, if there is one.
   */
  public static <T extends Dialog> T getFor(Class<T> type, IWorkbenchWindow workbenchWindow)
  {
    Map<Class<?>, Dockable> typedDialogs = DIALOGS.get(workbenchWindow);
    if (typedDialogs != null)
    {
      Dockable dockable = typedDialogs.get(type);
      if (dockable != null)
      {
        @SuppressWarnings("unchecked")
        T dialog = (T)dockable.getDialog();
        return dialog;
      }
    }

    return null;
  }

  /**
   * Close the instance for this workbench window, if there is one.
   */
  public static void closeFor(Class<? extends Dialog> type, IWorkbenchWindow workbenchWindow)
  {
    Map<Class<?>, Dockable> typedDialogs = DIALOGS.get(workbenchWindow);
    if (typedDialogs != null)
    {
      Dockable dockable = typedDialogs.get(type);
      if (dockable != null)
      {
        Shell shell = dockable.getShell();
        shell.notifyListeners(SWT.Close, new Event());
        dockable.close();
      }
    }
  }

  /**
   * Reopen or create the instance for this workbench window.
   */
  public static <T extends Dialog> T openFor(final Class<T> type, Factory<T> factory, final IWorkbenchWindow workbenchWindow)
  {
    // Create a new one if there isn't an existing one.
    Map<Class<?>, Dockable> typedDialogs = DIALOGS.get(workbenchWindow);

    Dockable dockable = typedDialogs == null ? null : typedDialogs.get(type);
    if (dockable == null)
    {
      dockable = ReflectUtil.invokeMethod("getDockable", factory.create(workbenchWindow));
      if (typedDialogs == null)
      {
        typedDialogs = new HashMap<Class<?>, Dockable>();
        DIALOGS.put(workbenchWindow, typedDialogs);
      }

      typedDialogs.put(type, dockable);

      dockable.open();

      Map<Class<?>, Set<IWorkbenchPartReference>> typedDockedParts = DOCKED_PARTS.get(workbenchWindow);
      Set<IWorkbenchPartReference> dockedParts = typedDockedParts == null ? null : typedDockedParts.get(type);
      boolean isInitial = false;
      if (dockedParts == null)
      {
        isInitial = true;
        dockedParts = new HashSet<IWorkbenchPartReference>();
        if (typedDockedParts == null)
        {
          typedDockedParts = new HashMap<Class<?>, Set<IWorkbenchPartReference>>();
          DOCKED_PARTS.put(workbenchWindow, typedDockedParts);
        }

        typedDockedParts.put(type, dockedParts);
      }

      // Clean up if the workbench window is disposed.
      final Shell windowShell = workbenchWindow.getShell();
      windowShell.addDisposeListener(WORKBENCH_DISPOSE_LISTENER);

      /**
       * This monitors the shell events, such as dragging to a new position.
       * It's primary purpose to to support docking of the dialog shell into a part stack on a workbench window.
       *
       * @author Ed Merks
       */
      class ShellHandler extends ShellAdapter implements ControlListener, DisposeListener, Runnable
      {
        private final Dockable dockableDialog;

        private final Shell shell;

        private final Display display;

        /**
         * A map from a tab folder (corresponding to a part stack) to the absolute display bounds where it is located.
         */
        private final Map<CTabFolder, Rectangle> tabFolders = new HashMap<CTabFolder, Rectangle>();

        /**
         * A map from a tab folder to the part references in that part stack.
         */
        private final Map<CTabFolder, Set<IWorkbenchPartReference>> tabFolderParts = new HashMap<CTabFolder, Set<IWorkbenchPartReference>>();

        /**
         * The cursor we show when in a docking location.
         */
        private final Cursor sizeAllCursor;

        /**
         * A listener that listens to the tab folder and to the overall workbench window to track resizing and movement so that the docking position can be maintained.
         */
        private final ControlListener dockingListener = new ControlListener()
        {
          public void controlResized(ControlEvent e)
          {
            update();
          }

          public void controlMoved(ControlEvent e)
          {
            update();
          }
        };

        /**
         * The point at which we most recently hovered in a location where we could dock the shell.
         */
        private Point snapPoint;

        /**
         * This is true only while we are doing the positioning of the shell.
         */
        private boolean ignoreControlMoved;

        /**
         * Because we don't receive events such as mouse moves or mouse clicks from the shell, we keep track of how and whether the cursor is moving.
         * @see #run()
         */
        private Point cursorLocation;

        /**
         * This records the most recent time the cursor has been moved to a different location.
         * @see #run()
         */
        private long timeOfLastCursorChange;

        /**
         * This records the most recent time {@link #update()} called {@link #setBounds(Rectangle)}.
         * @see #run()
         */
        private long timeOfLastUpdate;

        /**
         * This is the most recent bounds where we can dock the shell.
         */
        private Rectangle hotZone;

        /**
         * Because we want to be able to drag the docked shell slightly away from the docking site to undock it,
         * we keep track of the hot zone changes and ignore it initially for a short period of time.
         */
        private long timeOfLastHotZoneChange;

        /**
         * It's very hard to clear the hotZone and the snapPoint because we could just get no events when the interaction ends.
         * So we keep track of when the last time a moved happened and if a short period of time passes, we assume we're starting a new interaction.
         */
        private long timeOfLastMove;

        /**
         * This is set after docking.
         * When we hover in a docking position for a short period of time, we set the shell to be at that bounds of that hot zone.
         * But when the mouse is released the shell automatically will move to it's original position, for which we get an event,
         * and then we can use these bounds to set the shell back yet again to the right bounds.
         *
         * @see #dock(Rectangle)
         */
        private Rectangle snapBounds;

        /**
         * This the part stack where we are docked and that we will track when it resizes or moves.
         */
        private CTabFolder dockedTabFolder;

        /**
         * These are the part references at the part stack.
         * We record these so that if we turn to a new perspective, we can try to dock at a different part stack that contains one of the part references.
         */
        private final Set<IWorkbenchPartReference> dockedParts;

        private final Image shellImage;

        private final Image dockedShellImage;

        private final Image[] shellImages;

        private final Image[] dockedShellImages;

        public ShellHandler(Dockable dockableDialog, Set<IWorkbenchPartReference> dockedParts)
        {
          this.dockableDialog = dockableDialog;
          shell = dockableDialog.getShell();
          this.dockedParts = dockedParts;

          display = shell.getDisplay();
          sizeAllCursor = display.getSystemCursor(SWT.CURSOR_SIZEALL);

          shell.addShellListener(this);
          shell.addControlListener(this);
          shell.addDisposeListener(this);

          shellImage = shell.getImage();
          dockedShellImage = getDockedImage(shellImage);
          shellImages = shell.getImages();
          dockedShellImages = getDockedImages(shellImages);
        }

        @Override
        public void shellIconified(ShellEvent e)
        {
          updateActions(false);

          if (!OS.INSTANCE.isMac() && shell.isVisible())
          {
            shell.setVisible(false);
          }
        }

        @Override
        public void shellDeiconified(ShellEvent e)
        {
          if (shell.isVisible())
          {
            updateActions(true);
          }
        }

        protected void updateActions(boolean checked)
        {
          for (IAction action : dockableDialog.getActions())
          {
            action.setChecked(checked);
          }
        }

        public void controlResized(ControlEvent e)
        {
          if (OS.INSTANCE.isMac() && !ignoreControlMoved)
          {
            dock(null);
          }
        }

        public void controlMoved(ControlEvent e)
        {
          // When the shell is maximized, we get a moved event, and we can use that to clear the snap bounds
          // so that the restore goes back to the right position rather than the snap position.
          //
          boolean maximized = shell.getMaximized();
          if (maximized)
          {
            snapBounds = null;
          }

          // We do nothing if we are the ones moving the shell or the shell is maximized.
          // On Linux we see moves of the shell even when we did the update so use the time to guard it.
          if (!ignoreControlMoved && !maximized && (!OS.INSTANCE.isLinux() || System.currentTimeMillis() - timeOfLastUpdate > 500))
          {
            // We have snap bounds to apply, because releasing the mouse after docking moved the shell yet again, we can apply it now, and we never have to do
            // it again.
            if (snapBounds != null)
            {
              if (!OS.INSTANCE.isMac() || System.currentTimeMillis() - timeOfLastMove < 200)
              {
                setBounds(snapBounds);
                dock(snapBounds);
              }

              snapBounds = null;
            }
            // If we have a docking site...
            else if (dockedTabFolder != null)
            {
              // And we moved outside of it...
              if (!getBounds(dockedTabFolder).equals(shell.getBounds()))
              {
                // Undock the shell.
                dock(null);
              }
              else
              {
                // Otherwise we have moved to exactly the docking site, in which case we don't want to do anything!
                return;
              }
            }

            // If we haven't moved the shell for a short while, assume we're staring a new interaction.
            long newTimeOfLastMove = System.currentTimeMillis();
            if (newTimeOfLastMove - timeOfLastMove > 1000)
            {
              // On the Mac, we don't see any move events until the user stops moving the shell for a short while.
              // As such, the very first move event could be the last move event we'll ever see.
              // So in this case, start a new interaction only if we've not seen the cursor move for while.
              if (!OS.INSTANCE.isMac() || newTimeOfLastMove - timeOfLastCursorChange > 1000)
              {
                hotZone = null;
                snapPoint = null;
                snapBounds = null;
              }

              if (OS.INSTANCE.isMac())
              {
                // For the Mac, we want to start the heart beat runnable and there we'll monitor whether the cursor stays over the shell title for a period of
                // time.
                display.timerExec(100, this);
              }
            }

            timeOfLastMove = newTimeOfLastMove;

            // Determine the hot zone at the cursor location.
            Point cursorLocation = display.getCursorLocation();
            Rectangle newHotZone = getHotZone(cursorLocation);
            if (newHotZone != null)
            {
              // If it's a new one...
              if (!newHotZone.equals(hotZone))
              {
                // Keep track of when we first entered this new hot zone.
                timeOfLastHotZoneChange = System.currentTimeMillis();
                hotZone = newHotZone;
              }

              // If we've been in this hot zone for a short period of time...
              if (System.currentTimeMillis() - timeOfLastHotZoneChange > 400)
              {
                // If we have no snap point for this yet...
                if (snapPoint == null)
                {
                  // Show a different cursor and start the heart beat runnable.
                  shell.setCursor(sizeAllCursor);
                  updateShellImage(true);
                  display.timerExec(100, this);
                }

                // keep track of where we started.
                snapPoint = cursorLocation;
              }
            }
            else
            {
              // If we're outside of a hot zone, reset all the state.
              shell.setCursor(null);
              updateShellImage(false);
              snapPoint = null;
              hotZone = null;
              dock(null);
            }
          }
        }

        /**
         * This is the heart beat runnable that's started once we've hovered over a hot zone for a short period of time.
         */
        public void run()
        {
          if (shell.isDisposed())
          {
            return;
          }

          // Keep track of cursor movements, so that only if you hover for a while in the same location will the shell be snapped to the hot zone.
          Point newCursorLocation = display.getCursorLocation();
          if (cursorLocation == null || !cursorLocation.equals(newCursorLocation))
          {
            timeOfLastCursorChange = System.currentTimeMillis();
            cursorLocation = newCursorLocation;
          }

          // On the Mac, we'll check each time of the cursor control is not any part of any other window managed by SWT, i.e., it's staying inside the title
          // area of the shell.
          if (snapPoint == null && (!OS.INSTANCE.isMac() || display.getCursorControl() != null))
          {
            // Not in hot zone.
            shell.setCursor(null);
          }
          else if (System.currentTimeMillis() - timeOfLastCursorChange > 500)
          {
            // Get the bounds for the hot zone, and dock to that location.
            // The case of the snapPoint being null happens only on the Mac, in which case we use the current cursor location as the snap point.
            snapBounds = getHotZone(snapPoint == null ? cursorLocation : snapPoint);
            if (snapBounds != null)
            {
              setBounds(snapBounds);
              snapPoint = null;
              timeOfLastCursorChange = System.currentTimeMillis();
              dock(snapBounds);
              shell.setCursor(null);
            }
          }
          else
          {
            // Still moving the cursor, so check again in a while.
            display.timerExec(100, this);
          }
        }

        /**
         * Returns the hot zone rectangle if the cursor is within the tab area of that zone.
         */
        private Rectangle getHotZone(Point cursorLocation)
        {
          for (Rectangle rectangle : getHotZones())
          {
            final Rectangle hotZone = new Rectangle(rectangle.x, rectangle.y, rectangle.width, 30);
            if (hotZone.contains(cursorLocation))
            {
              return rectangle;
            }
          }

          return null;
        }

        /**
         * We call this when we set to bounds of the shell so that we can ignore the events we're causing ourselves.
         */
        private void setBounds(Rectangle bounds)
        {
          // On Linux we'll see later event for the move; one that we want to ignore.
          if (OS.INSTANCE.isLinux())
          {
            snapBounds = bounds;
            timeOfLastMove = System.currentTimeMillis();
          }

          ignoreControlMoved = true;
          shell.setBounds(bounds);
          ignoreControlMoved = false;
        }

        /**
         * Docks the shell at this rectangle.
         * We listen to the tab folder and the workbench window shell, so we need to maintain those listeners properly.
         */
        private void dock(Rectangle rectangle)
        {
          gatherTabFolders();

          // Remove any existing listeners.
          windowShell.removeControlListener(dockingListener);
          if (dockedTabFolder != null)
          {
            dockedTabFolder.removeControlListener(dockingListener);
          }

          // Clean up the docking points; they'll be populated new, if possible.
          dockedParts.clear();

          for (Map.Entry<CTabFolder, Rectangle> entry : tabFolders.entrySet())
          {
            if (entry.getValue().equals(rectangle))
            {
              // If we find an appropriate part stack,
              // add the listeners and record the information about the docking site and the part references associated with it.
              windowShell.addControlListener(dockingListener);
              dockedTabFolder = entry.getKey();
              dockedTabFolder.addControlListener(dockingListener);
              dockedParts.addAll(tabFolderParts.get(dockedTabFolder));
              updateShellImage(true);
              return;
            }
          }

          // Clear the recorded information to undock the shell.
          dockedTabFolder = null;
          updateShellImage(false);
        }

        private void updateShellImage(boolean docking)
        {
          if (shellImage != null)
          {
            shell.setImage(docking ? dockedShellImage : shellImage);
          }

          if (shellImages != null)
          {
            shell.setImages(docking ? dockedShellImages : shellImages);
          }

        }

        private void dispose()
        {
          // Clear up any docking listeners that might currently be in place.
          if (!windowShell.isDisposed())
          {
            windowShell.removeControlListener(dockingListener);
          }

          if (dockedTabFolder != null && !dockedTabFolder.isDisposed())
          {
            dockedTabFolder.removeControlListener(dockingListener);
          }
        }

        public void widgetDisposed(DisposeEvent e)
        {
          Map<Class<?>, Dockable> typedDialogs = DIALOGS.get(workbenchWindow);
          if (typedDialogs != null)
          {
            typedDialogs.remove(type);
          }

          for (IAction action : dockableDialog.getActions())
          {
            action.setChecked(false);
          }

          IDialogSettings dialogBoundsSettings = dockableDialog.getBoundsSettings();
          if (dialogBoundsSettings != null)
          {
            StringBuilder partIDs = new StringBuilder();
            for (IWorkbenchPartReference partReference : dockedParts)
            {
              if (partIDs.length() != 0)
              {
                partIDs.append(' ');
              }

              partIDs.append(partReference.getId());
            }

            dialogBoundsSettings.put("dockedParts", partIDs.toString());
          }

          dispose();
        }

        /**
         * This is called when the docking site or workbench window shell moves or changes because of perspective switching.
         */
        private void update()
        {
          if (!dockedParts.isEmpty() && (dockedTabFolder == null || !dockedTabFolder.isDisposed()))
          {
            gatherTabFolders();

            // If our docking site available or isn't visible...
            if (dockedTabFolder == null || !dockedTabFolder.isVisible())
            {
              // Find a new corresponding docking site, i.e., one that contains one of the part references in the part stack to which we're currently docked.
              for (IWorkbenchPartReference partReference : dockedParts)
              {
                for (Map.Entry<CTabFolder, Set<IWorkbenchPartReference>> entry : tabFolderParts.entrySet())
                {
                  if (entry.getValue().contains(partReference))
                  {
                    // Dock to this new replacement.
                    CTabFolder tabFolder = entry.getKey();
                    Rectangle bounds = getBounds(tabFolder);
                    setBounds(bounds);
                    dock(bounds);

                    timeOfLastUpdate = System.currentTimeMillis();

                    // If we've been forced to minimize the shell because there is no docking site in the perspective, but now we do have a docking site,
                    // make the shell visible again.
                    if (!shell.isVisible() && Boolean.TRUE.equals(shell.getData("forced")))
                    {
                      updateVisibility(shell, true);
                    }

                    return;
                  }
                }
              }

              if (dockedTabFolder != null)
              {
                updateVisibility(shell, false);
              }
            }
            else
            {
              // Get the new bounds for the docking site and apply them.
              // Restore the shell if it's been forced into minimized state.
              Rectangle bounds = getBounds(dockedTabFolder);
              setBounds(bounds);
              timeOfLastUpdate = System.currentTimeMillis();
              if (!shell.isVisible() && Boolean.TRUE.equals(shell.getData("forced")))
              {
                updateVisibility(shell, true);
              }
            }
          }
        }

        private void initialize()
        {
          IDialogSettings dialogBoundsSettings = dockableDialog.getBoundsSettings();
          if (dialogBoundsSettings != null)
          {
            String dockedPartIDs = dialogBoundsSettings.get("dockedParts");
            if (!StringUtil.isEmpty(dockedPartIDs))
            {
              gatherTabFolders();
              List<String> ids = StringUtil.explode(dockedPartIDs, " ");
              for (Set<IWorkbenchPartReference> partReferences : tabFolderParts.values())
              {
                for (IWorkbenchPartReference partReference : partReferences)
                {
                  if (ids.contains(partReference.getId()))
                  {
                    dockedParts.add(partReference);
                  }
                }
              }
            }
          }
        }

        private Collection<Rectangle> getHotZones()
        {
          gatherTabFolders();
          return tabFolders.values();
        }

        /**
         * Gets the bounds for the tab folder in display absolute coordinates.
         */
        private Rectangle getBounds(CTabFolder tabFolder)
        {
          Rectangle bounds = tabFolder.getBounds();
          Point displayPoint = tabFolder.getParent().toDisplay(bounds.x, bounds.y);
          bounds.x = displayPoint.x;
          bounds.y = displayPoint.y;

          // Make the bounds one pixel smaller on on sizes so that the shell's resize handles don't completely cover the tab folder's resize handles.
          if (OS.INSTANCE.isMac())
          {
            ++bounds.x;
            bounds.width -= 2;

            ++bounds.y;
            bounds.height -= 2;
          }

          return bounds;
        }

        public void gatherTabFolders()
        {
          tabFolders.clear();
          tabFolderParts.clear();

          // Visit all the part references of the page.
          IWorkbenchPage page = workbenchWindow.getActivePage();
          if (page != null)
          {
            IViewReference[] viewReferences = page.getViewReferences();
            for (IViewReference viewReference : viewReferences)
            {
              gatherTabFolders(viewReference);
            }

            IEditorReference[] editorReferences = page.getEditorReferences();
            for (IEditorReference editorReference : editorReferences)
            {
              gatherTabFolders(editorReference);
            }
          }
        }

        private void gatherTabFolders(IWorkbenchPartReference partReference)
        {
          // Get the widget associated the the part...
          Object part = ReflectUtil.getValue("part", partReference);
          if (part != null)
          {
            Object widget = ReflectUtil.invokeMethod("getWidget", part);
            if (widget instanceof Control)
            {
              // Walk up until we hit a visible tab folder.
              for (Control control = (Control)widget; control != null; control = control.getParent())
              {
                if (control.isVisible() && control instanceof CTabFolder)
                {
                  // Add it to the map, keeping track of the part references in each part stack.
                  CTabFolder tabFolder = (CTabFolder)control;
                  tabFolders.put(tabFolder, getBounds(tabFolder));
                  CollectionUtil.add(tabFolderParts, tabFolder, partReference);
                }
              }
            }
          }
        }
      }

      // Listen for shell and control events.
      final Shell shell = dockable.getShell();
      final ShellHandler shellHandler = new ShellHandler(dockable, dockedParts);

      // Listen to perspective changes so we can update the docking site as needed.
      workbenchWindow.addPerspectiveListener(new PerspectiveAdapter()
      {
        @Override
        public void perspectiveActivated(IWorkbenchPage page, IPerspectiveDescriptor perspective)
        {
          UIUtil.asyncExec(shell, new Runnable()
          {
            public void run()
            {
              shellHandler.update();
            }
          });
        }
      });

      if (isInitial)
      {
        shellHandler.initialize();
      }

      shellHandler.update();
    }
    else
    {
      // Show the shell if it already exists.
      final Shell shell = dockable.getShell();
      updateVisibility(shell, true);
    }

    @SuppressWarnings("unchecked")
    T dialog = (T)dockable.getDialog();
    return dialog;
  }
}