/*

 * Copyright (C) 2003, 2004 Joaquin Cuenca Abela

 *

 * Authors:

 *   Joaquin Cuenca Abela <e98cuenc@yahoo.com> 

 * 

 * 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 2 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, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

*/

#include "config.h"

/**

 * SECTION:glade-placeholder

 * @Short_Description: A #GtkWidget to fill empty places.

 *

 * Generally in Glade, container widgets are implemented with #GladePlaceholder 

 * children to allow users to 'click' and add thier widgets to a container. 

 * It is the responsability of the plugin writer to create placeholders for 

 * container widgets where appropriate; usually in #GladePostCreateFunc 

 * when the #GladeCreateReason is %GLADE_CREATE_USER.

 */

#include <gtk/gtk.h>

#include "glade-marshallers.h"

#include "glade.h"

#include "glade-placeholder.h"

#include "glade-xml-utils.h"

#include "glade-project.h"

#include "glade-command.h"

#include "glade-palette.h"

#include "glade-popup.h"

#include "glade-cursor.h"

#include "glade-widget.h"

#include "glade-app.h"

#include "glade-adaptor-chooser-widget.h"

#include <math.h>

#include "glade-dnd.h"

#include "glade-drag.h"

#define WIDTH_REQUISITION    20

#define HEIGHT_REQUISITION   20

static cairo_pattern_t *placeholder_pattern = NULL;

struct _GladePlaceholderPrivate

{

  GList *packing_actions;

  GdkWindow *event_window;

  gboolean drag_highlight;

};

enum

{

  PROP_0,

  PROP_HADJUSTMENT,

  PROP_VADJUSTMENT,

  PROP_HSCROLL_POLICY,

  PROP_VSCROLL_POLICY

};

#define GLADE_PLACEHOLDER_PRIVATE(object) (((GladePlaceholder*)object)->priv)

static void glade_placeholder_drag_init (_GladeDragInterface *iface);

G_DEFINE_TYPE_WITH_CODE (GladePlaceholder, glade_placeholder, GTK_TYPE_WIDGET,

                         G_ADD_PRIVATE (GladePlaceholder)

                         G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL)

                         G_IMPLEMENT_INTERFACE (GLADE_TYPE_DRAG, 

                                                glade_placeholder_drag_init))

static void

glade_placeholder_notify_parent (GObject    *gobject,

                                 GParamSpec *arg1,

                                 gpointer    user_data)

{

  GladePlaceholder *placeholder = GLADE_PLACEHOLDER (gobject);

  GladeWidgetAdaptor *parent_adaptor = NULL;

  GladeWidget *parent = glade_placeholder_get_parent (placeholder);

  if (placeholder->priv->packing_actions)

    {

      g_list_foreach (placeholder->priv->packing_actions, (GFunc) g_object_unref,

                      NULL);

      g_list_free (placeholder->priv->packing_actions);

      placeholder->priv->packing_actions = NULL;

    }

  if (parent)

    parent_adaptor = glade_widget_get_adaptor (parent);

  if (parent_adaptor)

    placeholder->priv->packing_actions =

      glade_widget_adaptor_pack_actions_new (parent_adaptor);

}

static void

glade_placeholder_init (GladePlaceholder *placeholder)

{

  placeholder->priv =  glade_placeholder_get_instance_private (placeholder);

  placeholder->priv->packing_actions = NULL;

  gtk_widget_set_can_focus (GTK_WIDGET (placeholder), TRUE);

  gtk_widget_set_has_window (GTK_WIDGET (placeholder), FALSE);

  gtk_widget_set_size_request (GTK_WIDGET (placeholder),

                               WIDTH_REQUISITION, HEIGHT_REQUISITION);

  _glade_dnd_dest_set (GTK_WIDGET (placeholder));

  g_signal_connect (placeholder, "notify::parent",

                    G_CALLBACK (glade_placeholder_notify_parent), NULL);

  gtk_widget_set_hexpand (GTK_WIDGET (placeholder), TRUE);

  gtk_widget_set_vexpand (GTK_WIDGET (placeholder), TRUE);

  gtk_widget_show (GTK_WIDGET (placeholder));

}

static void

glade_placeholder_finalize (GObject *object)

{

  GladePlaceholder *placeholder;

  g_return_if_fail (GLADE_IS_PLACEHOLDER (object));

  placeholder = GLADE_PLACEHOLDER (object);

  if (placeholder->priv->packing_actions)

    {

      g_list_foreach (placeholder->priv->packing_actions, (GFunc) g_object_unref, NULL);

      g_list_free (placeholder->priv->packing_actions);

    }

  G_OBJECT_CLASS (glade_placeholder_parent_class)->finalize (object);

}

static void

glade_placeholder_set_property (GObject      *object,

                                guint         prop_id,

                                const GValue *value,

                                GParamSpec   *pspec)

{

  switch (prop_id)

    {

      case PROP_HADJUSTMENT:

      case PROP_VADJUSTMENT:

      case PROP_HSCROLL_POLICY:

      case PROP_VSCROLL_POLICY:

        break;

      default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

        break;

    }

}

static void

glade_placeholder_get_property (GObject    *object,

                                guint       prop_id,

                                GValue     *value,

                                GParamSpec *pspec)

{

  switch (prop_id)

    {

      case PROP_HADJUSTMENT:

      case PROP_VADJUSTMENT:

        g_value_set_object (value, NULL);

        break;

      case PROP_HSCROLL_POLICY:

      case PROP_VSCROLL_POLICY:

        g_value_set_enum (value, GTK_SCROLL_MINIMUM);

        break;

      default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

        break;

    }

}

static void

glade_placeholder_realize (GtkWidget *widget)

{

  GladePlaceholder *placeholder;

  GtkAllocation allocation;

  GdkWindow *window;

  GdkWindowAttr attributes;

  gint attributes_mask;

  placeholder = GLADE_PLACEHOLDER (widget);

  gtk_widget_set_realized (widget, TRUE);

  gtk_widget_get_allocation (widget, &allocation);

  attributes.x = allocation.x;

  attributes.y = allocation.y;

  attributes.width = allocation.width;

  attributes.height = allocation.height;

  attributes.window_type = GDK_WINDOW_CHILD;

  attributes.wclass = GDK_INPUT_ONLY;

  attributes.event_mask =

      gtk_widget_get_events (widget) |

      GDK_POINTER_MOTION_MASK |

      GDK_POINTER_MOTION_HINT_MASK |

      GDK_BUTTON_PRESS_MASK |

      GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK;

  attributes_mask = GDK_WA_X | GDK_WA_Y;

  window = gtk_widget_get_parent_window (widget);

  gtk_widget_set_window (widget, g_object_ref (window));

  placeholder->priv->event_window =

      gdk_window_new (gtk_widget_get_parent_window (widget), &attributes,

                      attributes_mask);

  gdk_window_set_user_data (placeholder->priv->event_window, widget);

}

static void

glade_placeholder_unrealize (GtkWidget *widget)

{

  GladePlaceholder *placeholder;

  placeholder = GLADE_PLACEHOLDER (widget);

  if (placeholder->priv->event_window)

    {

      gdk_window_set_user_data (placeholder->priv->event_window, NULL);

      gdk_window_destroy (placeholder->priv->event_window);

      placeholder->priv->event_window = NULL;

    }

  GTK_WIDGET_CLASS (glade_placeholder_parent_class)->unrealize (widget);

}

static void

glade_placeholder_map (GtkWidget *widget)

{

  GladePlaceholder *placeholder;

  placeholder = GLADE_PLACEHOLDER (widget);

  if (placeholder->priv->event_window)

    {

      gdk_window_show (placeholder->priv->event_window);

    }

  GTK_WIDGET_CLASS (glade_placeholder_parent_class)->map (widget);

}

static void

glade_placeholder_unmap (GtkWidget *widget)

{

  GladePlaceholder *placeholder;

  placeholder = GLADE_PLACEHOLDER (widget);

  if (placeholder->priv->event_window)

    {

      gdk_window_hide (placeholder->priv->event_window);

    }

  GTK_WIDGET_CLASS (glade_placeholder_parent_class)->unmap (widget);

}

static void

glade_placeholder_size_allocate (GtkWidget *widget, GtkAllocation *allocation)

{

  GladePlaceholder *placeholder;

  placeholder = GLADE_PLACEHOLDER (widget);

  gtk_widget_set_allocation (widget, allocation);

  if (gtk_widget_get_realized (widget))

    {

      gdk_window_move_resize (placeholder->priv->event_window,

                              allocation->x, allocation->y,

                              allocation->width, allocation->height);

    }

}

static gboolean

glade_placeholder_draw (GtkWidget *widget, cairo_t *cr)

{

  GladePlaceholder *placeholder = GLADE_PLACEHOLDER (widget);

  gint h = gtk_widget_get_allocated_height (widget) - 1;

  gint w = gtk_widget_get_allocated_width (widget) - 1;

  if (placeholder_pattern)

    {

      cairo_save (cr);

      cairo_rectangle (cr, 0, 0, w, h);

      cairo_set_source (cr, placeholder_pattern);

      cairo_fill (cr);

      cairo_restore (cr);

    }

  cairo_translate (cr, .5, .5);

  cairo_set_line_width (cr, 1.0);

  /* We hardcode colors here since we are already using an image as bg pattern */

  cairo_set_source_rgb (cr, .9, .9, .9);

  cairo_move_to (cr, w, 0);

  cairo_line_to (cr, 0, 0);

  cairo_line_to (cr, 0, h);

  cairo_stroke (cr);

  cairo_set_source_rgb (cr, .64, .64, .64);

  cairo_move_to (cr, w, 0);

  cairo_line_to (cr, w, h);

  cairo_line_to (cr, 0, h);

  cairo_stroke (cr);

  if (placeholder->priv->drag_highlight)

    {

      cairo_pattern_t *gradient;

      GtkStyleContext *context;

      gdouble ww, hh;

      GdkRGBA c;

      context = gtk_widget_get_style_context (widget);

      gtk_style_context_save (context);

      gtk_style_context_get_background_color (context,

                                              gtk_style_context_get_state (context) |

                                              GTK_STATE_FLAG_SELECTED |

                                              GTK_STATE_FLAG_FOCUSED, &c);

      gtk_style_context_restore (context);

      ww = w/2.0;

      hh = h/2.0;

      gradient = cairo_pattern_create_radial (ww, hh, MIN (w, h)/6,

                                              ww, hh, MAX (ww, hh));

      cairo_pattern_add_color_stop_rgba (gradient, 0, c.red, c.green, c.blue, .08);

      cairo_pattern_add_color_stop_rgba (gradient, 1, c.red, c.green, c.blue, .28);

      cairo_set_source (cr, gradient);

      cairo_rectangle (cr, 0, 0, w, h);

      cairo_fill (cr);

      cairo_pattern_destroy (gradient);

    }

  return FALSE;

}

static void

glade_placeholder_update_cursor (GladePlaceholder *placeholder, GdkWindow *win)

{

  GladeProject *project = glade_placeholder_get_project (placeholder);

  GladePointerMode pointer_mode = glade_project_get_pointer_mode (project);

  if (pointer_mode == GLADE_POINTER_SELECT)

    glade_cursor_set (project, win, GLADE_CURSOR_SELECTOR);

  else if (pointer_mode == GLADE_POINTER_ADD_WIDGET)

    glade_cursor_set (project, win, GLADE_CURSOR_ADD_WIDGET);

}

static gboolean

glade_placeholder_enter_notify_event (GtkWidget        *widget, 

                                      GdkEventCrossing *event)

{

  glade_placeholder_update_cursor (GLADE_PLACEHOLDER (widget), event->window);

  return FALSE;

}

static gboolean

glade_placeholder_motion_notify_event (GtkWidget *widget, GdkEventMotion *event)

{

  glade_placeholder_update_cursor (GLADE_PLACEHOLDER (widget), event->window);

  return FALSE;

}

static void

on_chooser_adaptor_widget_selected (_GladeAdaptorChooserWidget *chooser,

                                    GladeWidgetAdaptor         *adaptor,

                                    GladePlaceholder           *placeholder)

{

  glade_command_create (adaptor, glade_placeholder_get_parent (placeholder),

                        placeholder, glade_placeholder_get_project (placeholder));

  gtk_widget_destroy (gtk_widget_get_ancestor (GTK_WIDGET (chooser), GTK_TYPE_POPOVER));

}

static GtkWidget *

glade_placeholder_popover_new (GladePlaceholder *placeholder, GtkWidget *relative_to)

{

  GtkWidget *pop = gtk_popover_new (relative_to);

  GtkWidget *chooser;

  chooser = _glade_adaptor_chooser_widget_new (GLADE_ADAPTOR_CHOOSER_WIDGET_WIDGET |

                                               GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_TOPLEVEL |

                                               GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_DEPRECATED,

                                               glade_placeholder_get_project (placeholder));

  _glade_adaptor_chooser_widget_populate (GLADE_ADAPTOR_CHOOSER_WIDGET (chooser));

  g_signal_connect (chooser, "adaptor-selected",

                    G_CALLBACK (on_chooser_adaptor_widget_selected),

                    placeholder);

  gtk_popover_set_position (GTK_POPOVER (pop), GTK_POS_BOTTOM);

  gtk_container_add (GTK_CONTAINER (pop), chooser);

  gtk_widget_show (chooser);

  return pop;

}

static gboolean

glade_placeholder_button_press (GtkWidget *widget, GdkEventButton *event)

{

  GladePlaceholder   *placeholder;

  GladeProject       *project;

  GladeWidgetAdaptor *adaptor;

  gboolean            handled = FALSE;

  g_return_val_if_fail (GLADE_IS_PLACEHOLDER (widget), FALSE);

  placeholder = GLADE_PLACEHOLDER (widget);

  project     = glade_placeholder_get_project (placeholder);

  adaptor     = glade_project_get_add_item (project);

  if (!gtk_widget_has_focus (widget))

    gtk_widget_grab_focus (widget);

  if ((event->button == 1 || event->button == 2) &&

       event->type == GDK_BUTTON_PRESS && adaptor != NULL)

    {

      GladeWidget *parent = glade_placeholder_get_parent (placeholder);

      /* A widget type is selected in the palette.

       * Add a new widget of that type.

       */

      glade_command_create (adaptor, parent, placeholder, project);

      /* Let the user use the middle button to create more than one widget */

      if (event->button != 2)

        {

          glade_project_set_add_item (project, NULL);

          /* reset the cursor */

          glade_project_set_pointer_mode (project, GLADE_POINTER_SELECT);

        }

      handled = TRUE;

    }

  else if (event->button == 1 &&

           event->type == GDK_2BUTTON_PRESS &&

           adaptor == NULL)

    {

      GtkWidget *event_widget = gtk_get_event_widget ((GdkEvent*) event);

      GladeWidget *toplevel = glade_widget_get_toplevel (glade_placeholder_get_parent (placeholder));

      GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (glade_widget_get_object (toplevel)));

      GtkWidget *pop = glade_placeholder_popover_new (placeholder, parent);

      GdkRectangle rect = {0, 0, 8, 8};

      gtk_widget_translate_coordinates (event_widget, parent,

                                        event->x, event->y,

                                        &rect.x, &rect.y);

      gtk_popover_set_pointing_to (GTK_POPOVER (pop), &rect);

      gtk_popover_popup (GTK_POPOVER (pop));

      handled = TRUE;

   }

  if (!handled && glade_popup_is_popup_event (event))

    {

      glade_popup_placeholder_pop (placeholder, event);

      handled = TRUE;

    }

  return handled;

}

static gboolean

glade_placeholder_popup_menu (GtkWidget *widget)

{

  g_return_val_if_fail (GLADE_IS_PLACEHOLDER (widget), FALSE);

  glade_popup_placeholder_pop (GLADE_PLACEHOLDER (widget), NULL);

  return TRUE;

}

static gboolean

glade_placeholder_drag_can_drag (_GladeDrag *source)

{

  GladeWidget *parent = glade_placeholder_get_parent (GLADE_PLACEHOLDER (source));

  return (parent) ? _glade_drag_can_drag (GLADE_DRAG (parent)) : FALSE;

}

static gboolean

glade_placeholder_drag_can_drop (_GladeDrag *dest, gint x, gint y, GObject *data)

{

  if (GLADE_IS_WIDGET_ADAPTOR (data))

    {

      GType otype = glade_widget_adaptor_get_object_type (GLADE_WIDGET_ADAPTOR (data));

      if (g_type_is_a (otype, GTK_TYPE_WIDGET) && !GWA_IS_TOPLEVEL (data))

        return TRUE;

    }

  else if (GTK_IS_WIDGET (data))

    {

      GladeWidget *parent, *new_child;

      /* Avoid recursion */

      if (gtk_widget_is_ancestor (GTK_WIDGET (dest), GTK_WIDGET (data)))

        return FALSE;

      parent = glade_placeholder_get_parent (GLADE_PLACEHOLDER (dest));

      if ((new_child = glade_widget_get_from_gobject (data)) &&

          !glade_widget_add_verify (parent, new_child, FALSE))

        return FALSE;

      return TRUE;

    }

  return FALSE;

}

static gboolean

glade_placeholder_drag_drop (_GladeDrag *dest, gint x, gint y, GObject *data)

{

  GladePlaceholder *placeholder = GLADE_PLACEHOLDER (dest);

  GladeWidget *gsource;

  if (!data)

    return FALSE;

  if (GLADE_IS_WIDGET_ADAPTOR (data))

    {

      GladeWidget *parent = glade_placeholder_get_parent (placeholder);

      glade_command_create (GLADE_WIDGET_ADAPTOR (data), parent, placeholder, 

                            glade_widget_get_project (parent));

      return TRUE;

    }

  else if ((gsource = glade_widget_get_from_gobject (data)))

    {

      GladeWidget *parent = glade_placeholder_get_parent (placeholder);

      GList widgets = {gsource, NULL, NULL};

      /* Check for recursive paste */

      if (parent != gsource)

        {

          glade_command_dnd (&widgets, parent, placeholder);

          return TRUE;

        }

    }

  return FALSE;

}

static void

glade_placeholder_drag_highlight (_GladeDrag *dest, gint x, gint y)

{

  GladePlaceholderPrivate *priv = GLADE_PLACEHOLDER (dest)->priv;

  gboolean highlight = !(x < 0 || y < 0);

  if (priv->drag_highlight == highlight)

    return;

  priv->drag_highlight = highlight;

  gtk_widget_queue_draw (GTK_WIDGET (dest));

}

static void

glade_placeholder_drag_init (_GladeDragInterface *iface)

{

  iface->can_drag = glade_placeholder_drag_can_drag;

  iface->can_drop = glade_placeholder_drag_can_drop;

  iface->drop = glade_placeholder_drag_drop;

  iface->highlight = glade_placeholder_drag_highlight;

}

static void

glade_placeholder_class_init (GladePlaceholderClass *klass)

{

  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  gchar *path;

  cairo_surface_t *surface;

  object_class->finalize = glade_placeholder_finalize;

  object_class->set_property = glade_placeholder_set_property;

  object_class->get_property = glade_placeholder_get_property;

  widget_class->realize = glade_placeholder_realize;

  widget_class->unrealize = glade_placeholder_unrealize;

  widget_class->map = glade_placeholder_map;

  widget_class->unmap = glade_placeholder_unmap;

  widget_class->size_allocate = glade_placeholder_size_allocate;

  widget_class->draw = glade_placeholder_draw;

  widget_class->enter_notify_event = glade_placeholder_enter_notify_event;

  widget_class->motion_notify_event = glade_placeholder_motion_notify_event;

  widget_class->button_press_event = glade_placeholder_button_press;

  widget_class->popup_menu = glade_placeholder_popup_menu;

  /* GtkScrollable implementation */

  g_object_class_override_property (object_class, PROP_HADJUSTMENT,

                                    "hadjustment");

  g_object_class_override_property (object_class, PROP_VADJUSTMENT,

                                    "vadjustment");

  g_object_class_override_property (object_class, PROP_HSCROLL_POLICY,

                                    "hscroll-policy");

  g_object_class_override_property (object_class, PROP_VSCROLL_POLICY,

                                    "vscroll-policy");

  /* Create our tiled background pattern */

  path = g_build_filename (glade_app_get_pixmaps_dir (), "placeholder.png", NULL);

  surface = cairo_image_surface_create_from_png (path);

  if (!surface)

    g_warning ("Failed to create surface for %s\n", path);

  else

    {

      placeholder_pattern = cairo_pattern_create_for_surface (surface);

      cairo_pattern_set_extend (placeholder_pattern, CAIRO_EXTEND_REPEAT);

    }

  g_free (path);

}

/**

 * glade_placeholder_new:

 * 

 * Returns: a new #GladePlaceholder cast as a #GtkWidget

 */

GtkWidget *

glade_placeholder_new (void)

{

  return g_object_new (GLADE_TYPE_PLACEHOLDER, NULL);

}

GladeProject *

glade_placeholder_get_project (GladePlaceholder *placeholder)

{

  GladeWidget *parent;

  parent = glade_placeholder_get_parent (placeholder);

  return parent ? glade_widget_get_project (parent) : NULL;

}

GladeWidget *

glade_placeholder_get_parent (GladePlaceholder *placeholder)

{

  GtkWidget *widget;

  GladeWidget *parent = NULL;

  g_return_val_if_fail (GLADE_IS_PLACEHOLDER (placeholder), NULL);

  for (widget = gtk_widget_get_parent (GTK_WIDGET (placeholder));

       widget != NULL; widget = gtk_widget_get_parent (widget))

    {

      if ((parent = glade_widget_get_from_gobject (widget)) != NULL)

        break;

    }

  return parent;

}

GList *

glade_placeholder_packing_actions (GladePlaceholder *placeholder)

{

  g_return_val_if_fail (GLADE_IS_PLACEHOLDER (placeholder), NULL);

  return placeholder->priv->packing_actions;

}