PIKApp/app/widgets/pikapanedbox.c

/* PIKA - Photo and Image Kooker Application
 * a rebranding of The GNU Image Manipulation Program (created with heckimp)
 * A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
 *
 * Original copyright, applying to most contents (license remains unchanged): 
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * pikapanedbox.c
 * Copyright (C) 2001-2005 Michael Natterer <mitch@gimp.org>
 * Copyright (C) 2009-2011 Martin Nordholts <martinn@src.gnome.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 <https://www.gnu.org/licenses/>.
 */

#include "config.h"

#include <gegl.h>
#include <gtk/gtk.h>

#include "libpikacolor/pikacolor.h"
#include "libpikawidgets/pikawidgets.h"

#include "widgets-types.h"

#include "core/pika.h"
#include "core/pikacontext.h"

#include "pikadialogfactory.h"
#include "pikadnd.h"
#include "pikadockable.h"
#include "pikadockbook.h"
#include "pikamenudock.h"
#include "pikapanedbox.h"
#include "pikatoolbox.h"
#include "pikawidgets-utils.h"

#include "pika-log.h"


/**
 * Defines the size of the area that dockables can be dropped on in
 * order to be inserted and get space on their own (rather than
 * inserted among others and sharing space)
 */
#define DROP_AREA_SIZE                  6

#define DROP_HIGHLIGHT_MIN_SIZE         32
#define DROP_HIGHLIGHT_COLOR            "#215d9c"
#define DROP_HIGHLIGHT_OPACITY_ACTIVE   0.8
#define DROP_HIGHLIGHT_OPACITY_INACTIVE 0.4

#define INSERT_INDEX_UNUSED             G_MININT


typedef struct
{
  gboolean      active;
  GeglRectangle area;
  gdouble       opacity;
} PikaPanedBoxHighlight;

struct _PikaPanedBoxPrivate
{
  /* Widgets that are separated by panes */
  GList                  *widgets;

  /* Is the DND highlight shown */
  PikaPanedBoxHighlight   dnd_highlights[3];
  gint                    dnd_n_highlights;
  GdkDragContext         *dnd_context;
  gint                    dnd_paned_position;
  gint                    dnd_idle_id;

  /* The insert index to use on drop */
  gint                    insert_index;

  /* Callback on drop */
  PikaPanedBoxDroppedFunc dropped_cb;
  gpointer                dropped_cb_data;

  /* A drag handler offered to handle drag events */
  PikaPanedBox           *drag_handler;
};


static void      pika_paned_box_dispose                 (GObject        *object);

static void      pika_paned_box_drag_leave              (GtkWidget      *widget,
                                                         GdkDragContext *context,
                                                         guint           time);
static gboolean  pika_paned_box_drag_motion             (GtkWidget      *widget,
                                                         GdkDragContext *context,
                                                         gint            x,
                                                         gint            y,
                                                         guint           time);
static gboolean  pika_paned_box_drag_drop               (GtkWidget      *widget,
                                                         GdkDragContext *context,
                                                         gint            x,
                                                         gint            y,
                                                         guint           time);
static void      pika_paned_box_drag_data_received      (GtkWidget      *widget,
                                                         GdkDragContext *context,
                                                         gint            x,
                                                         gint            y,
                                                         GtkSelectionData *data,
                                                         guint           info,
                                                         guint           time);
static void      pika_paned_box_set_widget_drag_handler (GtkWidget      *widget,
                                                         PikaPanedBox   *handler);
static gint      pika_paned_box_get_drop_area_size      (PikaPanedBox   *paned_box);
static void      pika_paned_box_hide_drop_indicator     (PikaPanedBox   *paned_box,
                                                         gint            index);

static void      pika_paned_box_drag_callback           (GdkDragContext *context,
                                                         gboolean        begin,
                                                         PikaPanedBox   *paned_box);


G_DEFINE_TYPE_WITH_PRIVATE (PikaPanedBox, pika_paned_box, GTK_TYPE_BOX)

#define parent_class pika_paned_box_parent_class

static const GtkTargetEntry dialog_target_table[] = { PIKA_TARGET_NOTEBOOK_TAB };

static GSList *drop_hints = NULL;


static void
pika_paned_box_class_init (PikaPanedBoxClass *klass)
{
  GObjectClass   *object_class = G_OBJECT_CLASS (klass);
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);

  object_class->dispose            = pika_paned_box_dispose;

  widget_class->drag_leave         = pika_paned_box_drag_leave;
  widget_class->drag_motion        = pika_paned_box_drag_motion;
  widget_class->drag_drop          = pika_paned_box_drag_drop;
  widget_class->drag_data_received = pika_paned_box_drag_data_received;
}

static void
pika_paned_box_init (PikaPanedBox *paned_box)
{
  paned_box->p = pika_paned_box_get_instance_private (paned_box);

  /* Setup DND */
  gtk_drag_dest_set (GTK_WIDGET (paned_box),
                     0,
                     dialog_target_table, G_N_ELEMENTS (dialog_target_table),
                     GDK_ACTION_MOVE);

  pika_dockbook_add_drag_callback (
    (PikaDockbookDragCallback) pika_paned_box_drag_callback,
    paned_box);
}

static void
pika_paned_box_dispose (GObject *object)
{
  PikaPanedBox *paned_box = PIKA_PANED_BOX (object);
  gsize         i;

  for (i = 0; i < G_N_ELEMENTS (paned_box->p->dnd_highlights); i++)
    pika_paned_box_hide_drop_indicator (paned_box, i);

  if (paned_box->p->dnd_idle_id)
    {
      g_source_remove (paned_box->p->dnd_idle_id);

      paned_box->p->dnd_idle_id = 0;
    }

  while (paned_box->p->widgets)
    {
      GtkWidget *widget = paned_box->p->widgets->data;

      g_object_ref (widget);
      pika_paned_box_remove_widget (paned_box, widget);
      gtk_widget_destroy (widget);
      g_object_unref (widget);
    }

  pika_dockbook_remove_drag_callback (
    (PikaDockbookDragCallback) pika_paned_box_drag_callback,
    paned_box);

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

static void
pika_paned_box_set_widget_drag_handler (GtkWidget    *widget,
                                        PikaPanedBox *drag_handler)
{
  /* Hook us in for drag events. We could abstract this properly and
   * put pika_paned_box_will_handle_drag() in an interface for
   * example, but it doesn't feel worth it at this point
   *
   * Note that we don't have 'else if's because a widget can be both a
   * dock and a toolbox for example, in which case we want to set a
   * drag handler in two ways
   *
   * We so need to introduce some abstractions here...
   */

  if (PIKA_IS_DOCKBOOK (widget))
    {
      pika_dockbook_set_drag_handler (PIKA_DOCKBOOK (widget),
                                      drag_handler);
    }

  if (PIKA_IS_DOCK (widget))
    {
      PikaPanedBox *dock_paned_box = NULL;
      dock_paned_box = PIKA_PANED_BOX (pika_dock_get_vbox (PIKA_DOCK (widget)));
      pika_paned_box_set_drag_handler (dock_paned_box, drag_handler);
    }

  if (PIKA_IS_TOOLBOX (widget))
    {
      PikaToolbox *toolbox = PIKA_TOOLBOX (widget);
      pika_toolbox_set_drag_handler (toolbox, drag_handler);
    }
}

static gint
pika_paned_box_get_drop_area_size (PikaPanedBox *paned_box)
{
  gint drop_area_size = 0;

  if (! paned_box->p->widgets)
    {
      GtkAllocation  allocation;
      GtkOrientation orientation;

      gtk_widget_get_allocation (GTK_WIDGET (paned_box), &allocation);
      orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (paned_box));

      if (orientation == GTK_ORIENTATION_HORIZONTAL)
        drop_area_size = allocation.width;
      else if (orientation == GTK_ORIENTATION_VERTICAL)
        drop_area_size = allocation.height;
    }

  drop_area_size = MAX (drop_area_size, DROP_AREA_SIZE);

  return drop_area_size;
}

static gboolean
pika_paned_box_get_handle_drag (PikaPanedBox   *paned_box,
                                GdkDragContext *context,
                                gint            x,
                                gint            y,
                                guint           time,
                                gint           *insert_index,
                                GeglRectangle  *area)
{
  gint           index          = INSERT_INDEX_UNUSED;
  GtkAllocation  allocation     = { 0, };
  gint           area_x         = 0;
  gint           area_y         = 0;
  gint           area_w         = 0;
  gint           area_h         = 0;
  GtkOrientation orientation    = 0;
  gint           drop_area_size = pika_paned_box_get_drop_area_size (paned_box);

  if (pika_paned_box_will_handle_drag (paned_box->p->drag_handler,
                                       GTK_WIDGET (paned_box),
                                       context,
                                       x, y,
                                       time))
    {
      return FALSE;
    }

  if (gtk_drag_dest_find_target (GTK_WIDGET (paned_box), context, NULL) ==
      GDK_NONE)
    {
      return FALSE;
    }

  gtk_widget_get_allocation (GTK_WIDGET (paned_box), &allocation);

  /* See if we're at the edge of the dock If there are no dockables,
   * the entire paned box is a drop area
   */
  orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (paned_box));
  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      area_y = 0;
      area_h = allocation.height;

      /* If there are no widgets, the drop area is as big as the paned
       * box
       */
      if (! paned_box->p->widgets)
        area_w = allocation.width;
      else
        area_w = drop_area_size;

      if (x < drop_area_size)
        {
          index = 0;
          area_x = 0;
        }
      if (x > allocation.width - drop_area_size)
        {
          index = -1;
          area_x = allocation.width - drop_area_size;
        }
    }
  else /* if (orientation = GTK_ORIENTATION_VERTICAL) */
    {
      area_x = 0;
      area_w = allocation.width;

      /* If there are no widgets, the drop area is as big as the paned
       * box
       */
      if (! paned_box->p->widgets)
        area_h = allocation.height;
      else
        area_h = drop_area_size;

      if (y < drop_area_size)
        {
          index = 0;
          area_y = 0;
        }
      if (y > allocation.height - drop_area_size)
        {
          index = -1;
          area_y = allocation.height - drop_area_size;
        }
    }

  if (area)
    {
      area->x      = allocation.x + area_x;
      area->y      = allocation.y + area_y;
      area->width  = area_w;
      area->height = area_h;
    }

  if (insert_index)
    *insert_index = index;

  return index != INSERT_INDEX_UNUSED;
}

static gboolean
pika_paned_box_drop_indicator_draw (GtkWidget *widget,
                                    cairo_t   *cr,
                                    gpointer   data)
{
  PikaPanedBox *paned_box = PIKA_PANED_BOX (widget);
  PikaRGB       color;
  gsize         i;

  pika_rgb_parse_hex (&color, DROP_HIGHLIGHT_COLOR, -1);

  for (i = 0; i < G_N_ELEMENTS (paned_box->p->dnd_highlights); i++)
    {
      const PikaPanedBoxHighlight *highlight = &paned_box->p->dnd_highlights[i];

      if (! highlight->active)
        continue;

      cairo_set_source_rgba (cr, color.r, color.g, color.b, highlight->opacity);

      cairo_rectangle (cr,
                       highlight->area.x,
                       highlight->area.y,
                       highlight->area.width,
                       highlight->area.height);

      cairo_fill (cr);
    }

  return FALSE;
}

static void
pika_paned_box_position_drop_indicator (PikaPanedBox        *paned_box,
                                        gint                 index,
                                        const GeglRectangle *area,
                                        gdouble              opacity)
{
  GtkWidget *widget = GTK_WIDGET (paned_box);

  paned_box->p->dnd_highlights[index].area    = *area;
  paned_box->p->dnd_highlights[index].opacity = opacity;

  if (! paned_box->p->dnd_highlights[index].active)
    {
      if (paned_box->p->dnd_n_highlights == 0)
        {
          g_signal_connect_after (
            widget, "draw",
            G_CALLBACK (pika_paned_box_drop_indicator_draw),
            NULL);
        }

      paned_box->p->dnd_highlights[index].active = TRUE;

      paned_box->p->dnd_n_highlights++;
    }

  gtk_widget_queue_draw (widget);
}

static void
pika_paned_box_hide_drop_indicator (PikaPanedBox *paned_box,
                                    gint          index)
{
  GtkWidget *widget = GTK_WIDGET (paned_box);

  if (paned_box->p->dnd_highlights[index].active)
    {
      paned_box->p->dnd_highlights[index].active = FALSE;

      paned_box->p->dnd_n_highlights--;

      if (paned_box->p->dnd_n_highlights == 0)
        {
          g_signal_handlers_disconnect_by_func (
            widget,
            pika_paned_box_drop_indicator_draw,
            NULL);
        }
    }

  gtk_widget_queue_draw (widget);
}

static void
pika_paned_box_drag_leave (GtkWidget      *widget,
                           GdkDragContext *context,
                           guint           time)
{
  pika_paned_box_hide_drop_indicator (PIKA_PANED_BOX (widget), 0);
}

static gboolean
pika_paned_box_drag_motion (GtkWidget      *widget,
                            GdkDragContext *context,
                            gint            x,
                            gint            y,
                            guint           time)
{
  PikaPanedBox  *paned_box = PIKA_PANED_BOX (widget);
  gint           insert_index;
  GeglRectangle  area;
  gboolean       handle;

  handle = pika_paned_box_get_handle_drag (paned_box, context, x, y, time,
                                           &insert_index, &area);

  /* If we are at the edge, show a highlight to communicate that a
   * drop will create a new dock column
   */
  if (handle)
    {
      pika_paned_box_position_drop_indicator (paned_box,
                                              0,
                                              &area,
                                              DROP_HIGHLIGHT_OPACITY_ACTIVE);
    }
  else
    {
      pika_paned_box_hide_drop_indicator (paned_box, 0);
    }

  /* Save the insert index for drag-drop */
  paned_box->p->insert_index = insert_index;

  gdk_drag_status (context, handle ? GDK_ACTION_MOVE : 0, time);

  /* Return TRUE so drag_leave() is called */
  return handle;
}

static gboolean
pika_paned_box_drag_drop (GtkWidget      *widget,
                          GdkDragContext *context,
                          gint            x,
                          gint            y,
                          guint           time)
{
  PikaPanedBox *paned_box = PIKA_PANED_BOX (widget);
  GdkAtom       target;

  if (pika_paned_box_will_handle_drag (paned_box->p->drag_handler,
                                       widget,
                                       context,
                                       x, y,
                                       time))
    {
      return FALSE;
    }

  target = gtk_drag_dest_find_target (widget, context, NULL);

  if (target == GDK_NONE)
    return FALSE;

  gtk_drag_get_data (widget, context, target, time);

  return TRUE;
}

static void
pika_paned_box_drag_data_received (GtkWidget        *widget,
                                   GdkDragContext   *context,
                                   gint              x,
                                   gint              y,
                                   GtkSelectionData *data,
                                   guint             info,
                                   guint             time)
{
  PikaPanedBox  *paned_box = PIKA_PANED_BOX (widget);
  GtkWidget     *notebook  = gtk_drag_get_source_widget (context);
  GtkWidget    **child     = (gpointer) gtk_selection_data_get_data (data);
  gboolean      dropped    = FALSE;

  if (paned_box->p->dropped_cb)
    {
      dropped = paned_box->p->dropped_cb (notebook,
                                          *child,
                                          paned_box->p->insert_index,
                                          paned_box->p->dropped_cb_data);
    }

  gtk_drag_finish (context, dropped, TRUE, time);
}

static gboolean
pika_paned_box_drag_callback_idle (PikaPanedBox *paned_box)
{
  GtkAllocation  allocation;
  GtkOrientation orientation;
  GeglRectangle  area;

  paned_box->p->dnd_idle_id = 0;

  gtk_widget_get_allocation (GTK_WIDGET (paned_box), &allocation);
  orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (paned_box));

  #define ADD_AREA(index, left, top)             \
    if (pika_paned_box_get_handle_drag (         \
        paned_box,                               \
        paned_box->p->dnd_context,               \
        (left), (top),                           \
        0,                                       \
        NULL, &area))                            \
      {                                          \
        pika_paned_box_position_drop_indicator ( \
          paned_box,                             \
          index,                                 \
          &area,                                 \
          DROP_HIGHLIGHT_OPACITY_INACTIVE);      \
      }

  if (! paned_box->p->widgets)
    {
      ADD_AREA (1, allocation.width / 2, allocation.height / 2)
    }
  else if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      ADD_AREA (1, 0,                    allocation.height / 2)
      ADD_AREA (2, allocation.width - 1, allocation.height / 2)
    }
  else
    {
      ADD_AREA (1, allocation.width / 2, 0)
      ADD_AREA (2, allocation.width / 2, allocation.height - 1)
    }

  #undef ADD_AREA

  return G_SOURCE_REMOVE;
}

static void
pika_paned_box_drag_callback (GdkDragContext *context,
                              gboolean        begin,
                              PikaPanedBox   *paned_box)
{
  GtkWidget *paned;
  gint       position;

  if (! gtk_widget_get_sensitive (GTK_WIDGET (paned_box)))
    return;

  paned = gtk_widget_get_ancestor (GTK_WIDGET (paned_box),
                                   GTK_TYPE_PANED);

  /* apparently, we can be called multiple times when beginning a drag
   * (possibly a gtk bug); make sure not to leak the idle.
   *
   * see issue #4895.
   */
  if (begin && ! paned_box->p->dnd_context)
    {
      paned_box->p->dnd_context = context;

      if (paned)
        {
          GtkAllocation allocation;

          gtk_widget_get_allocation (paned, &allocation);

          position = gtk_paned_get_position (GTK_PANED (paned));

          paned_box->p->dnd_paned_position = position;

          if (position < 0)
            {
              position = 0;
            }
          else if (gtk_widget_is_ancestor (
                     GTK_WIDGET (paned_box),
                     gtk_paned_get_child2 (GTK_PANED (paned))))
            {
              position = allocation.width - position;
            }

          if (position < DROP_HIGHLIGHT_MIN_SIZE)
            {
              position = DROP_HIGHLIGHT_MIN_SIZE;

              if (gtk_widget_is_ancestor (
                    GTK_WIDGET (paned_box),
                    gtk_paned_get_child2 (GTK_PANED (paned))))
                {
                  position = allocation.width - position;
                }

              gtk_paned_set_position (GTK_PANED (paned), position);
            }
        }

      paned_box->p->dnd_idle_id = g_idle_add (
        (GSourceFunc) pika_paned_box_drag_callback_idle,
        paned_box);
    }
  else if (! begin && paned_box->p->dnd_context)
    {
      if (paned_box->p->dnd_idle_id)
        {
          g_source_remove (paned_box->p->dnd_idle_id);

          paned_box->p->dnd_idle_id = 0;
        }

      paned_box->p->dnd_context = NULL;

      pika_paned_box_hide_drop_indicator (paned_box, 1);
      pika_paned_box_hide_drop_indicator (paned_box, 2);

      if (paned)
        {
          gtk_paned_set_position (GTK_PANED (paned),
                                  paned_box->p->dnd_paned_position);
        }
    }
}

GtkWidget *
pika_paned_box_new (gboolean       homogeneous,
                    gint           spacing,
                    GtkOrientation orientation)
{
  return g_object_new (PIKA_TYPE_PANED_BOX,
                       "homogeneous",  homogeneous,
                       "spacing",      0,
                       "orientation",  orientation,
                       NULL);
}

void
pika_paned_box_set_dropped_cb (PikaPanedBox            *paned_box,
                               PikaPanedBoxDroppedFunc  dropped_cb,
                               gpointer                 dropped_cb_data)
{
  g_return_if_fail (PIKA_IS_PANED_BOX (paned_box));

  paned_box->p->dropped_cb      = dropped_cb;
  paned_box->p->dropped_cb_data = dropped_cb_data;
}

/**
 * pika_paned_box_add_widget:
 * @paned_box: A #PikaPanedBox
 * @widget:    The #GtkWidget to add
 * @index:     Where to add the @widget
 *
 * Add a #GtkWidget to the #PikaPanedBox in a hierarchy of #GtkPaned:s
 * so the space can be manually distributed between the widgets.
 **/
void
pika_paned_box_add_widget (PikaPanedBox *paned_box,
                           GtkWidget    *widget,
                           gint          index)
{
  gint old_length = 0;

  g_return_if_fail (PIKA_IS_PANED_BOX (paned_box));
  g_return_if_fail (GTK_IS_WIDGET (widget));

  PIKA_LOG (DND, "Adding GtkWidget %p to PikaPanedBox %p", widget, paned_box);

  /* Calculate length */
  old_length = g_list_length (paned_box->p->widgets);

  /* If index is invalid append at the end */
  if (index >= old_length || index < 0)
    {
      index = old_length;
    }

  /* Insert into the list */
  paned_box->p->widgets = g_list_insert (paned_box->p->widgets, widget, index);

  /* Hook us in for drag events. We could abstract this but it doesn't
   * seem worth it at this point
   */
  pika_paned_box_set_widget_drag_handler (widget, paned_box);

  /* Insert into the GtkPaned hierarchy */
  if (old_length == 0)
    {
      /* A widget is added, hide the instructions */
      //gtk_widget_hide (paned_box->p->instructions);
      drop_hints = g_slist_remove (drop_hints, paned_box);

      gtk_box_pack_start (GTK_BOX (paned_box), widget, TRUE, TRUE, 0);
    }
  else
    {
      GtkWidget      *old_widget;
      GtkWidget      *parent;
      GtkWidget      *paned;
      GtkOrientation  orientation;

      /* Figure out what widget to detach */
      if (index == 0)
        {
          old_widget = g_list_nth_data (paned_box->p->widgets, index + 1);
        }
      else
        {
          old_widget = g_list_nth_data (paned_box->p->widgets, index - 1);
        }

      parent = gtk_widget_get_parent (old_widget);

      if (old_length > 1 && index > 0)
        {
          GtkWidget *grandparent = gtk_widget_get_parent (parent);

          old_widget = parent;
          parent     = grandparent;
        }

      /* Detach the widget and build up a new hierarchy */
      g_object_ref (old_widget);
      gtk_container_remove (GTK_CONTAINER (parent), old_widget);

      /* GtkPaned is abstract :( */
      orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (paned_box));
      paned = gtk_paned_new (orientation);
      gtk_paned_set_wide_handle (GTK_PANED (paned), TRUE);

      if (GTK_IS_PANED (parent))
        {
          gtk_paned_pack1 (GTK_PANED (parent), paned, TRUE, FALSE);
        }
      else
        {
          gtk_box_pack_start (GTK_BOX (parent), paned, TRUE, TRUE, 0);
        }
      gtk_widget_show (paned);

      if (index == 0)
        {
          gtk_paned_pack1 (GTK_PANED (paned), widget,
                           TRUE, FALSE);
          gtk_paned_pack2 (GTK_PANED (paned), old_widget,
                           TRUE, FALSE);
        }
      else
        {
          gtk_paned_pack1 (GTK_PANED (paned), old_widget,
                           TRUE, FALSE);
          gtk_paned_pack2 (GTK_PANED (paned), widget,
                           TRUE, FALSE);
        }

      g_object_unref (old_widget);
    }
}

/**
 * pika_paned_box_remove_widget:
 * @paned_box: A #PikaPanedBox
 * @widget:    The #GtkWidget to remove
 *
 * Remove a #GtkWidget from a #PikaPanedBox added with
 * pika_widgets_add_paned_widget().
 **/
void
pika_paned_box_remove_widget (PikaPanedBox *paned_box,
                              GtkWidget    *widget)
{
  gint       old_length   = 0;
  gint       index        = 0;
  GtkWidget *other_widget = NULL;
  GtkWidget *parent       = NULL;
  GtkWidget *grandparent  = NULL;

  g_return_if_fail (PIKA_IS_PANED_BOX (paned_box));
  g_return_if_fail (GTK_IS_WIDGET (widget));

  PIKA_LOG (DND, "Removing GtkWidget %p from PikaPanedBox %p", widget, paned_box);

  /* Calculate length and index */
  old_length = g_list_length (paned_box->p->widgets);
  index      = g_list_index (paned_box->p->widgets, widget);

  /* Remove from list */
  paned_box->p->widgets = g_list_remove (paned_box->p->widgets, widget);

  /* Reset the drag events hook */
  pika_paned_box_set_widget_drag_handler (widget, NULL);

  /* Remove from widget hierarchy */
  if (old_length == 1)
    {
      /* The widget might already be parent-less if we are in
       * destruction, .e.g when closing a dock window.
       */
      if (gtk_widget_get_parent (widget) != NULL)
        gtk_container_remove (GTK_CONTAINER (paned_box), widget);

      /* The last widget is removed, show the instructions */
      //gtk_widget_show (paned_box->p->instructions);
      drop_hints = g_slist_prepend (drop_hints, paned_box);
    }
  else
    {
      g_object_ref (widget);

      parent      = gtk_widget_get_parent (GTK_WIDGET (widget));
      grandparent = gtk_widget_get_parent (parent);

      if (index == 0)
        other_widget = gtk_paned_get_child2 (GTK_PANED (parent));
      else
        other_widget = gtk_paned_get_child1 (GTK_PANED (parent));

      g_object_ref (other_widget);

      gtk_container_remove (GTK_CONTAINER (parent), other_widget);
      gtk_container_remove (GTK_CONTAINER (parent), GTK_WIDGET (widget));

      gtk_container_remove (GTK_CONTAINER (grandparent), parent);

      if (GTK_IS_PANED (grandparent))
        gtk_paned_pack1 (GTK_PANED (grandparent), other_widget, TRUE, FALSE);
      else
        gtk_box_pack_start (GTK_BOX (paned_box), other_widget, TRUE, TRUE, 0);

      g_object_unref (other_widget);

      g_object_unref (widget);
    }
}

/**
 * pika_paned_box_will_handle_drag:
 * @paned_box: A #PikaPanedBox
 * @widget:    The widget that got the drag event
 * @context:   Context from drag event
 * @x:         x from drag event
 * @y:         y from drag event
 * @time:      time from drag event
 *
 * Returns: %TRUE if the drag event on @widget will be handled by
 *          @paned_box.
 **/
gboolean
pika_paned_box_will_handle_drag (PikaPanedBox   *paned_box,
                                 GtkWidget      *widget,
                                 GdkDragContext *context,
                                 gint            x,
                                 gint            y,
                                 gint            time)
{
  gint           paned_box_x    = 0;
  gint           paned_box_y    = 0;
  GtkAllocation  allocation     = { 0, };
  GtkOrientation orientation    = 0;
  gboolean       will_handle    = FALSE;
  gint           drop_area_size = 0;

  g_return_val_if_fail (paned_box == NULL ||
                        PIKA_IS_PANED_BOX (paned_box), FALSE);

  /* Check for NULL to allow cleaner client code */
  if (paned_box == NULL)
    return FALSE;

  /* Our handler might handle it */
  if (pika_paned_box_will_handle_drag (paned_box->p->drag_handler,
                                       widget,
                                       context,
                                       x, y,
                                       time))
    {
      /* Return TRUE so the client will pass on the drag event */
      return TRUE;
    }

  /* If we don't have a common ancenstor we will not handle it */
  if (! gtk_widget_translate_coordinates (widget,
                                          GTK_WIDGET (paned_box),
                                          x, y,
                                          &paned_box_x, &paned_box_y))
    {
      /* Return FALSE so the client can take care of the drag event */
      return FALSE;
    }

  /* We now have paned_box coordinates, see if the paned_box will
   * handle the event
   */
  gtk_widget_get_allocation (GTK_WIDGET (paned_box), &allocation);
  orientation    = gtk_orientable_get_orientation (GTK_ORIENTABLE (paned_box));
  drop_area_size = pika_paned_box_get_drop_area_size (paned_box);
  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      will_handle = (paned_box_x < drop_area_size ||
                     paned_box_x > allocation.width - drop_area_size);
    }
  else /*if (orientation = GTK_ORIENTATION_VERTICAL)*/
    {
      will_handle = (paned_box_y < drop_area_size ||
                     paned_box_y > allocation.height - drop_area_size);
    }

  return will_handle;
}

void
pika_paned_box_set_drag_handler (PikaPanedBox *paned_box,
                                 PikaPanedBox *drag_handler)
{
  g_return_if_fail (PIKA_IS_PANED_BOX (paned_box));

  paned_box->p->drag_handler = drag_handler;
}