gimp/app/widgets/gimpdockbook.c

/* GIMP - The GNU Image Manipulation Program
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * gimpdockbook.c
 * Copyright (C) 2001-2007 Michael Natterer <mitch@gimp.org>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"

#undef GSEAL_ENABLE

#include <string.h>

#include <gtk/gtk.h>

#include "libgimpwidgets/gimpwidgets.h"

#include "widgets-types.h"

#include "core/gimpcontext.h"
#include "core/gimpmarshal.h"

#include "gimpdnd.h"
#include "gimpdock.h"
#include "gimpdockable.h"
#include "gimpdockbook.h"
#include "gimpdocked.h"
#include "gimpdockwindow.h"
#include "gimphelp-ids.h"
#include "gimpmenufactory.h"
#include "gimppanedbox.h"
#include "gimpstringaction.h"
#include "gimpuimanager.h"
#include "gimpview.h"
#include "gimpwidgets-utils.h"

#include "gimp-log.h"

#define DEFAULT_TAB_BORDER     0
#define DEFAULT_TAB_ICON_SIZE  GTK_ICON_SIZE_BUTTON
#define DND_WIDGET_ICON_SIZE   GTK_ICON_SIZE_BUTTON
#define MENU_WIDGET_ICON_SIZE  GTK_ICON_SIZE_MENU
#define MENU_WIDGET_SPACING    4
#define TAB_HOVER_TIMEOUT      500


enum
{
  DOCKABLE_ADDED,
  DOCKABLE_REMOVED,
  DOCKABLE_REORDERED,
  LAST_SIGNAL
};

struct _GimpDockbookPrivate
{
  GimpDock      *dock;
  GimpUIManager *ui_manager;

  guint          tab_hover_timeout;
  GimpDockable  *tab_hover_dockable;

  GimpPanedBox  *drag_handler;
};


static void      gimp_dockbook_dispose            (GObject        *object);
static void      gimp_dockbook_finalize           (GObject        *object);

static void      gimp_dockbook_style_set          (GtkWidget      *widget,
                                                   GtkStyle       *prev_style);

static void      gimp_dockbook_drag_leave         (GtkWidget      *widget,
                                                   GdkDragContext *context,
                                                   guint           time);
static gboolean  gimp_dockbook_drag_motion        (GtkWidget      *widget,
                                                   GdkDragContext *context,
                                                   gint            x,
                                                   gint            y,
                                                   guint           time);
static gboolean  gimp_dockbook_drag_drop          (GtkWidget      *widget,
                                                   GdkDragContext *context,
                                                   gint            x,
                                                   gint            y,
                                                   guint           time);

static void      gimp_dockbook_dockable_added     (GimpDockbook   *dockbook,
                                                   GimpDockable   *dockable);
static void      gimp_dockbook_dockable_removed   (GimpDockbook   *dockbook,
                                                   GimpDockable   *dockable);
static void      gimp_dockbook_update_tabs        (GimpDockbook   *dockbook,
                                                   gboolean        added);

static void      gimp_dockbook_tab_drag_source_setup (GtkWidget    *widget,
                                                      GimpDockable *dockable);
static void      gimp_dockbook_tab_drag_begin     (GtkWidget      *widget,
                                                   GdkDragContext *context,
                                                   GimpDockable   *dockable);
static void      gimp_dockbook_tab_drag_end       (GtkWidget      *widget,
                                                   GdkDragContext *context,
                                                   GimpDockable   *dockable);

static void      gimp_dockbook_tab_drag_leave     (GtkWidget      *widget,
                                                   GdkDragContext *context,
                                                   guint           time,
                                                   GimpDockable   *dockable);
static gboolean  gimp_dockbook_tab_drag_motion    (GtkWidget      *widget,
                                                   GdkDragContext *context,
                                                   gint            x,
                                                   gint            y,
                                                   guint           time,
                                                   GimpDockable   *dockable);
static gboolean  gimp_dockbook_tab_drag_drop      (GtkWidget      *widget,
                                                   GdkDragContext *context,
                                                   gint            x,
                                                   gint            y,
                                                   guint           time);

static void      gimp_dockbook_add_tab_timeout    (GimpDockbook   *dockbook,
                                                   GimpDockable   *dockable);
static void      gimp_dockbook_remove_tab_timeout (GimpDockbook   *dockbook);
static gboolean  gimp_dockbook_tab_timeout        (GimpDockbook   *dockbook);
static void      gimp_dockbook_tab_locked_notify  (GimpDockable   *dockable,
                                                   GParamSpec     *pspec,
                                                   GimpDockbook   *dockbook);

static void      gimp_dockbook_help_func          (const gchar    *help_id,
                                                   gpointer        help_data);


G_DEFINE_TYPE (GimpDockbook, gimp_dockbook, GTK_TYPE_NOTEBOOK)

#define parent_class gimp_dockbook_parent_class

static guint dockbook_signals[LAST_SIGNAL] = { 0 };

static const GtkTargetEntry dialog_target_table[] = { GIMP_TARGET_DIALOG };


static void
gimp_dockbook_class_init (GimpDockbookClass *klass)
{
  GObjectClass   *object_class = G_OBJECT_CLASS (klass);
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);

  dockbook_signals[DOCKABLE_ADDED] =
    g_signal_new ("dockable-added",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (GimpDockbookClass, dockable_added),
                  NULL, NULL,
                  gimp_marshal_VOID__OBJECT,
                  G_TYPE_NONE, 1,
                  GIMP_TYPE_DOCKABLE);

  dockbook_signals[DOCKABLE_REMOVED] =
    g_signal_new ("dockable-removed",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (GimpDockbookClass, dockable_removed),
                  NULL, NULL,
                  gimp_marshal_VOID__OBJECT,
                  G_TYPE_NONE, 1,
                  GIMP_TYPE_DOCKABLE);

  dockbook_signals[DOCKABLE_REORDERED] =
    g_signal_new ("dockable-reordered",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (GimpDockbookClass, dockable_reordered),
                  NULL, NULL,
                  gimp_marshal_VOID__OBJECT,
                  G_TYPE_NONE, 1,
                  GIMP_TYPE_DOCKABLE);

  object_class->dispose     = gimp_dockbook_dispose;
  object_class->finalize    = gimp_dockbook_finalize;

  widget_class->style_set   = gimp_dockbook_style_set;
  widget_class->drag_leave  = gimp_dockbook_drag_leave;
  widget_class->drag_motion = gimp_dockbook_drag_motion;
  widget_class->drag_drop   = gimp_dockbook_drag_drop;

  klass->dockable_added     = gimp_dockbook_dockable_added;
  klass->dockable_removed   = gimp_dockbook_dockable_removed;
  klass->dockable_reordered = NULL;

  gtk_widget_class_install_style_property (widget_class,
                                           g_param_spec_int ("tab-border",
                                                             NULL, NULL,
                                                             0, G_MAXINT,
                                                             DEFAULT_TAB_BORDER,
                                                             GIMP_PARAM_READABLE));
  gtk_widget_class_install_style_property (widget_class,
                                           g_param_spec_enum ("tab-icon-size",
                                                              NULL, NULL,
                                                              GTK_TYPE_ICON_SIZE,
                                                              DEFAULT_TAB_ICON_SIZE,
                                                              GIMP_PARAM_READABLE));

  g_type_class_add_private (klass, sizeof (GimpDockbookPrivate));
}

static void
gimp_dockbook_init (GimpDockbook *dockbook)
{
  dockbook->p = G_TYPE_INSTANCE_GET_PRIVATE (dockbook,
                                             GIMP_TYPE_DOCKBOOK,
                                             GimpDockbookPrivate);
  dockbook->p->dock       = NULL;
  dockbook->p->ui_manager = NULL;

  gtk_notebook_popup_enable (GTK_NOTEBOOK (dockbook));
  gtk_notebook_set_scrollable (GTK_NOTEBOOK (dockbook), TRUE);
  gtk_notebook_set_show_border (GTK_NOTEBOOK (dockbook), FALSE);

  gtk_drag_dest_set (GTK_WIDGET (dockbook),
                     0,
                     dialog_target_table, G_N_ELEMENTS (dialog_target_table),
                     GDK_ACTION_MOVE);
}

static void
gimp_dockbook_dispose (GObject *object)
{
  GimpDockbook *dockbook = GIMP_DOCKBOOK (object);

  gimp_dockbook_remove_tab_timeout (dockbook);

  G_OBJECT_CLASS (parent_class)->dispose (object);
}

static void
gimp_dockbook_finalize (GObject *object)
{
  GimpDockbook *dockbook = GIMP_DOCKBOOK (object);

  if (dockbook->p->ui_manager)
    {
      g_object_unref (dockbook->p->ui_manager);
      dockbook->p->ui_manager = NULL;
    }

  G_OBJECT_CLASS (parent_class)->finalize (object);
}

static void
gimp_dockbook_style_set (GtkWidget *widget,
                         GtkStyle  *prev_style)
{
  GList *children;
  GList *list;
  gint   tab_border;

  GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);

  gtk_widget_style_get (widget,
                        "tab-border", &tab_border,
                        NULL);

  g_object_set (widget,
                "tab-border", tab_border,
                NULL);

  children = gtk_container_get_children (GTK_CONTAINER (widget));

  for (list = children; list; list = g_list_next (list))
    {
      GtkWidget *tab_widget;

      tab_widget = gimp_dockbook_create_tab_widget (GIMP_DOCKBOOK (widget),
                                                    GIMP_DOCKABLE (list->data));

      gtk_notebook_set_tab_label (GTK_NOTEBOOK (widget),
                                  GTK_WIDGET (list->data),
                                  tab_widget);
    }

  g_list_free (children);
}

static void
gimp_dockbook_drag_leave (GtkWidget      *widget,
                          GdkDragContext *context,
                          guint           time)
{
  gimp_highlight_widget (widget, FALSE);
}

static gboolean
gimp_dockbook_drag_motion (GtkWidget      *widget,
                           GdkDragContext *context,
                           gint            x,
                           gint            y,
                           guint           time)
{
  GimpDockbook *dockbook          = GIMP_DOCKBOOK (widget);
  gboolean      other_will_handle = FALSE;

  other_will_handle = gimp_paned_box_will_handle_drag (dockbook->p->drag_handler,
                                                       widget,
                                                       context,
                                                       x, y,
                                                       time);

  gdk_drag_status (context, other_will_handle ? 0 : GDK_ACTION_MOVE, time);
  gimp_highlight_widget (widget, ! other_will_handle);
  return other_will_handle ? FALSE : TRUE;
}

static gboolean
gimp_dockbook_drag_drop (GtkWidget      *widget,
                         GdkDragContext *context,
                         gint            x,
                         gint            y,
                         guint           time)
{
  GimpDockbook *dockbook = GIMP_DOCKBOOK (widget);
  gboolean      handled  = FALSE;

  if (gimp_paned_box_will_handle_drag (dockbook->p->drag_handler,
                                       widget,
                                       context,
                                       x, y,
                                       time))
    {
      /* Make event fall through to the drag handler */
      handled = FALSE;
    }
  else
    {
      handled =
        gimp_dockbook_drop_dockable (dockbook,
                                     gtk_drag_get_source_widget (context));
    }

  /* We must call gtk_drag_finish() ourselves */
  if (handled)
    gtk_drag_finish (context, TRUE, TRUE, time);

  return handled;
}

static void
gimp_dockbook_dockable_added (GimpDockbook *dockbook,
                              GimpDockable *dockable)
{
  gimp_dockbook_update_tabs (dockbook, TRUE);

  gtk_notebook_set_current_page (GTK_NOTEBOOK (dockbook),
                                 gtk_notebook_page_num (GTK_NOTEBOOK (dockbook),
                                                        GTK_WIDGET (dockable)));
}

static void
gimp_dockbook_dockable_removed (GimpDockbook *dockbook,
                                GimpDockable *dockable)
{
  gimp_dockbook_update_tabs (dockbook, FALSE);
}

static void
gimp_dockbook_update_tabs (GimpDockbook *dockbook,
                           gboolean      added)
{
  switch (gtk_notebook_get_n_pages (GTK_NOTEBOOK (dockbook)))
    {
    case 1:
      gtk_notebook_set_show_tabs (GTK_NOTEBOOK (dockbook), FALSE);
      break;

    case 2:
      if (added)
        gtk_notebook_set_show_tabs (GTK_NOTEBOOK (dockbook), TRUE);
      break;

    default:
      break;
    }
}

GtkWidget *
gimp_dockbook_new (GimpMenuFactory *menu_factory)
{
  GimpDockbook *dockbook;

  g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);

  dockbook = g_object_new (GIMP_TYPE_DOCKBOOK, NULL);

  dockbook->p->ui_manager = gimp_menu_factory_manager_new (menu_factory,
                                                        "<Dockable>",
                                                        dockbook,
                                                        FALSE);

  gimp_help_connect (GTK_WIDGET (dockbook), gimp_dockbook_help_func,
                     GIMP_HELP_DOCK, dockbook);

  return GTK_WIDGET (dockbook);
}

GimpDock *
gimp_dockbook_get_dock (GimpDockbook *dockbook)
{
  g_return_val_if_fail (GIMP_IS_DOCKBOOK (dockbook), NULL);

  return dockbook->p->dock;
}

void
gimp_dockbook_set_dock (GimpDockbook *dockbook,
                        GimpDock     *dock)
{
  g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
  g_return_if_fail (dock == NULL || GIMP_IS_DOCK (dock));

  dockbook->p->dock = dock;
}

GimpUIManager *
gimp_dockbook_get_ui_manager (GimpDockbook *dockbook)
{
  g_return_val_if_fail (GIMP_IS_DOCKBOOK (dockbook), NULL);

  return dockbook->p->ui_manager;
}

void
gimp_dockbook_add (GimpDockbook *dockbook,
                   GimpDockable *dockable,
                   gint          position)
{
  GtkWidget *tab_widget;
  GtkWidget *menu_widget;

  g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
  g_return_if_fail (dockbook->p->dock != NULL);
  g_return_if_fail (GIMP_IS_DOCKABLE (dockable));
  g_return_if_fail (dockable->dockbook == NULL);

  GIMP_LOG (DND, "Adding GimpDockable %p to GimpDockbook %p", dockable, dockbook);

  tab_widget = gimp_dockbook_create_tab_widget (dockbook, dockable);

  g_return_if_fail (GTK_IS_WIDGET (tab_widget));

  gimp_dockable_set_drag_handler (dockable, dockbook->p->drag_handler);

  menu_widget = gimp_dockable_get_tab_widget (dockable,
                                              gimp_dock_get_context (dockbook->p->dock),
                                              GIMP_TAB_STYLE_ICON_BLURB,
                                              MENU_WIDGET_ICON_SIZE);

  g_return_if_fail (GTK_IS_WIDGET (menu_widget));

  if (position == -1)
    {
      gtk_notebook_append_page_menu (GTK_NOTEBOOK (dockbook),
                                     GTK_WIDGET (dockable),
                                     tab_widget,
                                     menu_widget);
    }
  else
    {
      gtk_notebook_insert_page_menu (GTK_NOTEBOOK (dockbook),
                                     GTK_WIDGET (dockable),
                                     tab_widget,
                                     menu_widget,
                                     position);
    }

  gtk_widget_show (GTK_WIDGET (dockable));

  dockable->dockbook = dockbook;

  gimp_dockable_set_context (dockable, gimp_dock_get_context (dockbook->p->dock));

  g_signal_connect (dockable, "notify::locked",
                    G_CALLBACK (gimp_dockbook_tab_locked_notify),
                    dockbook);

  g_signal_emit (dockbook, dockbook_signals[DOCKABLE_ADDED], 0, dockable);
}

void
gimp_dockbook_remove (GimpDockbook *dockbook,
                      GimpDockable *dockable)
{
  GList *children;

  g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
  g_return_if_fail (GIMP_IS_DOCKABLE (dockable));
  g_return_if_fail (dockable->dockbook == dockbook);

  GIMP_LOG (DND, "Removing GimpDockable %p from GimpDockbook %p", dockable, dockbook);

  gimp_dockable_set_drag_handler (dockable, NULL);

  g_object_ref (dockable);

  g_signal_handlers_disconnect_by_func (dockable,
                                        G_CALLBACK (gimp_dockbook_tab_locked_notify),
                                        dockbook);

  if (dockbook->p->tab_hover_dockable == dockable)
    gimp_dockbook_remove_tab_timeout (dockbook);

  dockable->dockbook = NULL;

  gimp_dockable_set_context (dockable, NULL);

  gtk_container_remove (GTK_CONTAINER (dockbook), GTK_WIDGET (dockable));

  g_signal_emit (dockbook, dockbook_signals[DOCKABLE_REMOVED], 0, dockable);

  g_object_unref (dockable);

  children = gtk_container_get_children (GTK_CONTAINER (dockbook));

  if (! g_list_length (children))
    gimp_dock_remove_book (dockbook->p->dock, dockbook);

  g_list_free (children);
}

GtkWidget *
gimp_dockbook_create_tab_widget (GimpDockbook *dockbook,
                                 GimpDockable *dockable)
{
  GtkWidget      *tab_widget;
  GimpDockWindow *dock_window;
  GtkIconSize     tab_size = DEFAULT_TAB_ICON_SIZE;
  GtkAction      *action   = NULL;

  gtk_widget_style_get (GTK_WIDGET (dockbook),
                        "tab-icon-size", &tab_size,
                        NULL);

  tab_widget = gimp_dockable_get_tab_widget (dockable,
                                             gimp_dock_get_context (dockbook->p->dock),
                                             dockable->tab_style,
                                             tab_size);

  if (! GIMP_IS_VIEW (tab_widget))
    {
      GtkWidget *event_box;

      event_box = gtk_event_box_new ();
      gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);
      gtk_event_box_set_above_child (GTK_EVENT_BOX (event_box), TRUE);
      gtk_container_add (GTK_CONTAINER (event_box), tab_widget);
      gtk_widget_show (tab_widget);

      tab_widget = event_box;
    }

  /* EEK */
  dock_window = gimp_dock_window_from_dock (dockbook->p->dock);
  if (dock_window && gimp_dock_window_get_ui_manager (dock_window))
    {
      const gchar *dialog_id;

      dialog_id = g_object_get_data (G_OBJECT (dockable),
                                     "gimp-dialog-identifier");

      if (dialog_id)
        {
          GimpActionGroup *group;

          group = gimp_ui_manager_get_action_group
            (gimp_dock_window_get_ui_manager (dock_window), "dialogs");

          if (group)
            {
              GList *actions;
              GList *list;

              actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (group));

              for (list = actions; list; list = g_list_next (list))
                {
                  if (GIMP_IS_STRING_ACTION (list->data) &&
                      strstr (GIMP_STRING_ACTION (list->data)->value,
                              dialog_id))
                    {
                      action = list->data;
                      break;
                    }
                }

              g_list_free (actions);
            }
        }
    }

  if (action)
    gimp_widget_set_accel_help (tab_widget, action);
  else
    gimp_help_set_help_data (tab_widget, dockable->blurb, dockable->help_id);

  g_object_set_data (G_OBJECT (tab_widget), "gimp-dockable", dockable);

  gimp_dockbook_tab_drag_source_setup (tab_widget, dockable);

  g_signal_connect (tab_widget, "drag-begin",
                    G_CALLBACK (gimp_dockbook_tab_drag_begin),
                    dockable);
  g_signal_connect (tab_widget, "drag-end",
                    G_CALLBACK (gimp_dockbook_tab_drag_end),
                    dockable);

  g_signal_connect (dockable, "drag-begin",
                    G_CALLBACK (gimp_dockbook_tab_drag_begin),
                    dockable);
  g_signal_connect (dockable, "drag-end",
                    G_CALLBACK (gimp_dockbook_tab_drag_end),
                    dockable);

  gtk_drag_dest_set (tab_widget,
                     0,
                     dialog_target_table, G_N_ELEMENTS (dialog_target_table),
                     GDK_ACTION_MOVE);
  g_signal_connect (tab_widget, "drag-leave",
                    G_CALLBACK (gimp_dockbook_tab_drag_leave),
                    dockable);
  g_signal_connect (tab_widget, "drag-motion",
                    G_CALLBACK (gimp_dockbook_tab_drag_motion),
                    dockable);
  g_signal_connect (tab_widget, "drag-drop",
                    G_CALLBACK (gimp_dockbook_tab_drag_drop),
                    dockbook);

  return tab_widget;
}

gboolean
gimp_dockbook_drop_dockable (GimpDockbook *dockbook,
                             GtkWidget    *drag_source)
{
  g_return_val_if_fail (GIMP_IS_DOCKBOOK (dockbook), FALSE);

  if (drag_source)
    {
      GimpDockable *dockable =
        gimp_dockbook_drag_source_to_dockable (drag_source);

      if (dockable)
        {
          if (dockable->dockbook == dockbook)
            {
              gtk_notebook_reorder_child (GTK_NOTEBOOK (dockbook),
                                          GTK_WIDGET (dockable), -1);
            }
          else
            {
              g_object_ref (dockable);

              gimp_dockbook_remove (dockable->dockbook, dockable);
              gimp_dockbook_add (dockbook, dockable, -1);

              g_object_unref (dockable);
            }

          return TRUE;
        }
    }

  return FALSE;
}

/**
 * gimp_dockable_set_drag_handler:
 * @dockable:
 * @handler:
 *
 * Set a drag handler that will be asked if it will handle drag events
 * before the dockbook handles the event itself.
 **/
void
gimp_dockbook_set_drag_handler (GimpDockbook *dockbook,
                                GimpPanedBox *drag_handler)
{
  g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));

  dockbook->p->drag_handler = drag_handler;
}

/**
 * gimp_dockbook_drag_source_to_dockable:
 * @drag_source: A drag-and-drop source widget
 *
 * Gets the dockable associated with a drag-and-drop source. If
 * successfull, the function will also cleanup the dockable.
 *
 * Returns: The dockable
 **/
GimpDockable *
gimp_dockbook_drag_source_to_dockable (GtkWidget *drag_source)
{
  GimpDockable *dockable = NULL;

  if (GIMP_IS_DOCKABLE (drag_source))
    dockable = GIMP_DOCKABLE (drag_source);
  else
    dockable = g_object_get_data (G_OBJECT (drag_source),
                                  "gimp-dockable");
  if (dockable)
    g_object_set_data (G_OBJECT (dockable),
                       "gimp-dock-drag-widget", NULL);

  return dockable;
}

/*  tab DND source side  */

static void
gimp_dockbook_tab_drag_source_setup (GtkWidget    *widget,
                                     GimpDockable *dockable)
{
  if (gimp_dockable_is_locked (dockable))
    {
      if (widget)
        gtk_drag_source_unset (widget);

      gtk_drag_source_unset (GTK_WIDGET (dockable));
    }
  else
    {
      if (widget)
        gtk_drag_source_set (widget,
                             GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
                             dialog_target_table,
                             G_N_ELEMENTS (dialog_target_table),
                             GDK_ACTION_MOVE);

      gtk_drag_source_set (GTK_WIDGET (dockable),
                           GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
                           dialog_target_table,
                           G_N_ELEMENTS (dialog_target_table),
                           GDK_ACTION_MOVE);
    }
}

static void
gimp_dockbook_tab_drag_begin (GtkWidget      *widget,
                              GdkDragContext *context,
                              GimpDockable   *dockable)
{
  GimpDock          *dock;
  GimpPanedBoxClass *paned_box_class;
  GtkWidget         *window;
  GtkWidget         *view;
  GtkRequisition     requisition;

  dock            = GIMP_DOCK (dockable->dockbook->p->dock);
  paned_box_class = GIMP_PANED_BOX_GET_CLASS (gimp_dock_get_vbox (dock));

  window = gtk_window_new (GTK_WINDOW_POPUP);
  gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DND);
  gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (widget));

  view = gimp_dockable_get_drag_widget (dockable);
  gtk_container_add (GTK_CONTAINER (window), view);
  gtk_widget_show (view);

  gtk_widget_size_request (view, &requisition);

  if (requisition.width < widget->allocation.width)
    gtk_widget_set_size_request (view, widget->allocation.width, -1);

  gtk_widget_show (window);

  g_object_set_data_full (G_OBJECT (dockable), "gimp-dock-drag-widget",
                          window,
                          (GDestroyNotify) gtk_widget_destroy);

  gtk_drag_set_icon_widget (context, window,
                            dockable->drag_x, dockable->drag_y);

  /*
   * Set the source dockable insensitive to give a visual clue that
   * it's the dockable that's being dragged around
   */
  gtk_widget_set_sensitive (GTK_WIDGET (dockable), FALSE);
}

static void
gimp_dockbook_tab_drag_end (GtkWidget      *widget,
                            GdkDragContext *context,
                            GimpDockable   *dockable)
{
  GimpDock          *dock;
  GimpPanedBoxClass *paned_box_class;
  GtkWidget         *drag_widget;

  dock            = GIMP_DOCK (dockable->dockbook->p->dock);
  paned_box_class = GIMP_PANED_BOX_GET_CLASS (gimp_dock_get_vbox (dock));
  drag_widget     = g_object_get_data (G_OBJECT (dockable),
                                       "gimp-dock-drag-widget");

  /*  finding the drag_widget means the drop was not successful, so
   *  pop up a new dock and move the dockable there
   */
  if (drag_widget)
    {
      g_object_set_data (G_OBJECT (dockable), "gimp-dock-drag-widget", NULL);
      gimp_dockable_detach (dockable);
    }

  dockable->drag_x = GIMP_DOCKABLE_DRAG_OFFSET;
  dockable->drag_y = GIMP_DOCKABLE_DRAG_OFFSET;
  gtk_widget_set_sensitive (GTK_WIDGET (dockable), TRUE);
}


/*  tab DND target side  */

static void
gimp_dockbook_tab_drag_leave (GtkWidget      *widget,
                              GdkDragContext *context,
                              guint           time,
                              GimpDockable   *dockable)
{
  GimpDockbook *dockbook = dockable->dockbook;

  gimp_dockbook_remove_tab_timeout (dockbook);

  gimp_highlight_widget (widget, FALSE);
}

static gboolean
gimp_dockbook_tab_drag_motion (GtkWidget      *widget,
                               GdkDragContext *context,
                               gint            x,
                               gint            y,
                               guint           time,
                               GimpDockable   *dockable)
{
  GimpDockbook  *dockbook = dockable->dockbook;
  GtkTargetList *target_list;
  GdkAtom        target_atom;
  gboolean       handle   = FALSE;

  /* If the handler will handle the drag, return FALSE */
  if (gimp_paned_box_will_handle_drag (dockbook->p->drag_handler,
                                       widget,
                                       context,
                                       x, y,
                                       time))
    {
      handle = FALSE;
      goto finish;
    }

  if (! dockbook->p->tab_hover_timeout ||
      dockbook->p->tab_hover_dockable != dockable)
    {
      gint page_num;

      gimp_dockbook_remove_tab_timeout (dockbook);

      page_num = gtk_notebook_page_num (GTK_NOTEBOOK (dockbook),
                                        GTK_WIDGET (dockable));

      if (page_num != gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook)))
        gimp_dockbook_add_tab_timeout (dockbook, dockable);
    }

  target_list = gtk_drag_dest_get_target_list (widget);
  target_atom = gtk_drag_dest_find_target (widget, context, target_list);

  handle = gtk_target_list_find (target_list, target_atom, NULL);

 finish:
  gdk_drag_status (context, handle ? GDK_ACTION_MOVE : 0, time);
  gimp_highlight_widget (widget, handle);
  return handle;
}

static gboolean
gimp_dockbook_tab_drag_drop (GtkWidget      *widget,
                             GdkDragContext *context,
                             gint            x,
                             gint            y,
                             guint           time)
{
  GimpDockable *dest_dockable;
  GtkWidget    *source;
  gboolean      handle = FALSE;

  dest_dockable = g_object_get_data (G_OBJECT (widget), "gimp-dockable");

  source = gtk_drag_get_source_widget (context);

  /* If the handler will handle the drag, return FALSE */
  if (gimp_paned_box_will_handle_drag (dest_dockable->drag_handler,
                                       widget,
                                       context,
                                       x, y,
                                       time))
    {
      handle = FALSE;
      goto finish;
    }

  if (dest_dockable && source)
    {
      GimpDockable *src_dockable =
        gimp_dockbook_drag_source_to_dockable (source);

      if (src_dockable)
        {
          gint dest_index;

          dest_index =
            gtk_notebook_page_num (GTK_NOTEBOOK (dest_dockable->dockbook),
                                   GTK_WIDGET (dest_dockable));

          if (src_dockable->dockbook != dest_dockable->dockbook)
            {
              g_object_ref (src_dockable);

              gimp_dockbook_remove (src_dockable->dockbook, src_dockable);
              gimp_dockbook_add (dest_dockable->dockbook, src_dockable,
                                 dest_index);

              g_object_unref (src_dockable);

              handle = TRUE;
            }
          else if (src_dockable != dest_dockable)
            {
              gtk_notebook_reorder_child (GTK_NOTEBOOK (src_dockable->dockbook),
                                          GTK_WIDGET (src_dockable),
                                          dest_index);

              g_signal_emit (src_dockable->dockbook,
                             dockbook_signals[DOCKABLE_REORDERED], 0,
                             src_dockable);

              handle = TRUE;
            }
        }
    }

 finish:
  if (handle)
    gtk_drag_finish (context, TRUE, TRUE, time);

  return handle;
}

static void
gimp_dockbook_add_tab_timeout (GimpDockbook *dockbook,
                               GimpDockable *dockable)
{
  dockbook->p->tab_hover_timeout =
    g_timeout_add (TAB_HOVER_TIMEOUT,
                   (GSourceFunc) gimp_dockbook_tab_timeout,
                   dockbook);

  dockbook->p->tab_hover_dockable = dockable;
}

static void
gimp_dockbook_remove_tab_timeout (GimpDockbook *dockbook)
{
  if (dockbook->p->tab_hover_timeout)
    {
      g_source_remove (dockbook->p->tab_hover_timeout);
      dockbook->p->tab_hover_timeout  = 0;
      dockbook->p->tab_hover_dockable = NULL;
    }
}

static gboolean
gimp_dockbook_tab_timeout (GimpDockbook *dockbook)
{
  gint page_num;

  GDK_THREADS_ENTER ();

  page_num = gtk_notebook_page_num (GTK_NOTEBOOK (dockbook),
                                    GTK_WIDGET (dockbook->p->tab_hover_dockable));
  gtk_notebook_set_current_page (GTK_NOTEBOOK (dockbook), page_num);

  dockbook->p->tab_hover_timeout  = 0;
  dockbook->p->tab_hover_dockable = NULL;

  GDK_THREADS_LEAVE ();

  return FALSE;
}

static void
gimp_dockbook_tab_locked_notify (GimpDockable *dockable,
                                 GParamSpec   *pspec,
                                 GimpDockbook *dockbook)
{
  GtkWidget *tab_widget;

  tab_widget = gtk_notebook_get_tab_label (GTK_NOTEBOOK (dockbook),
                                           GTK_WIDGET (dockable));

  gimp_dockbook_tab_drag_source_setup (tab_widget, dockable);
}

static void
gimp_dockbook_help_func (const gchar *help_id,
                         gpointer     help_data)
{
  GimpDockbook *dockbook = GIMP_DOCKBOOK (help_data);
  GtkWidget    *dockable;
  gint          page_num;

  page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook));

  dockable = gtk_notebook_get_nth_page (GTK_NOTEBOOK (dockbook), page_num);

  if (GIMP_IS_DOCKABLE (dockable))
    gimp_standard_help_func (GIMP_DOCKABLE (dockable)->help_id, NULL);
  else
    gimp_standard_help_func (GIMP_HELP_DOCK, NULL);
}