/*

 * glade-design-view.c

 *

 * Copyright (C)      2006 Vincent Geddes

 *               2011-2016 Juan Pablo Ugarte

 *

 * Authors:

 *   Vincent Geddes <vincent.geddes@gmail.com>

 *   Juan Pablo Ugarte <juanpablougarte@gmail.com>

 *

 * This library is free software; you can redistribute it and/or modify it

 * under the terms of the GNU Lesser General Public License as

 * published by the Free Software Foundation; either version 2.1 of

 * the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser 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.

 *

 */

/**

 * SECTION:glade-design-view

 * @Title: GladeDesignView

 * @Short_Description: A widget to embed the workspace.

 *

 * Use this widget to embed toplevel widgets in a given #GladeProject.

 */

#include "config.h"

#include "glade.h"

#include "glade-dnd.h"

#include "glade-utils.h"

#include "glade-design-view.h"

#include "glade-design-layout.h"

#include "glade-design-private.h"

#include "glade-path.h"

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

#include <glib.h>

#include <glib/gi18n.h>

#define GLADE_DESIGN_VIEW_KEY "GLADE_DESIGN_VIEW_KEY"

enum

{

  PROP_0,

  PROP_PROJECT

};

struct _GladeDesignViewPrivate

{

  GladeProject *project;

  GtkWidget *scrolled_window;  /* Main scrolled window */

  GtkWidget *layout_box;       /* Box to pack a GladeDesignLayout for each toplevel in project */

  _GladeDrag *drag_target;

  GObject *drag_data;

  gboolean drag_highlight;

};

static GtkVBoxClass *parent_class = NULL;

static void glade_design_view_drag_init (_GladeDragInterface *iface);

G_DEFINE_TYPE_WITH_CODE (GladeDesignView, glade_design_view, GTK_TYPE_BOX,

                         G_ADD_PRIVATE (GladeDesignView)

                         G_IMPLEMENT_INTERFACE (GLADE_TYPE_DRAG,

                                                glade_design_view_drag_init))

static void

glade_design_layout_scroll (GladeDesignView *view, gint x, gint y, gint w, gint h)

{

  gdouble vadj_val, hadj_val, vpage_end, hpage_end;

  GtkAdjustment *vadj, *hadj;

  vadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (view->priv->scrolled_window));

  hadj = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (view->priv->scrolled_window));

  vadj_val = gtk_adjustment_get_value (vadj);

  hadj_val = gtk_adjustment_get_value (hadj);

  vpage_end = gtk_adjustment_get_page_size (vadj) + vadj_val;

  hpage_end = gtk_adjustment_get_page_size (hadj) + hadj_val;

  /* TODO: we could set this value in increments in a timeout callback 

   * to make it look like its scrolling instead of jumping.

   */

  if (y < vadj_val || y > vpage_end || (y + h) > vpage_end)

    gtk_adjustment_set_value (vadj, y);

  if (x < hadj_val || x > hpage_end || (x + w) > hpage_end)

    gtk_adjustment_set_value (hadj, x);

}

static void 

on_layout_size_allocate (GtkWidget *widget, GtkAllocation *alloc, GladeDesignView *view)

{

  glade_design_layout_scroll (view, alloc->x, alloc->y, alloc->width, alloc->height);

  g_signal_handlers_disconnect_by_func (widget, on_layout_size_allocate, view);

}

static void

glade_design_view_update_state (GList *objects, GtkStateFlags state)

{

  GList *l;

  for (l = objects; l && l->data; l = g_list_next (l))

    {

      GtkWidget *view, *widget = l->data;

      if (GTK_IS_WIDGET (widget) &&

          gtk_widget_get_visible (widget) &&

          (view = gtk_widget_get_ancestor (widget, GLADE_TYPE_DESIGN_LAYOUT)))

        {

          gtk_widget_set_state_flags (view, state, TRUE);

        }

    }

}

static void

glade_design_view_selection_changed (GladeProject *project, GladeDesignView *view)

{

  GtkWidget *layout;

  GList *selection;

  glade_design_view_update_state (glade_project_toplevels (project),

                                  GTK_STATE_FLAG_NORMAL);

  if (!(selection = glade_project_selection_get (project)))

    return;

  glade_design_view_update_state (selection, GTK_STATE_FLAG_SELECTED);

  /* Check if its only one widget selected and scroll viewport to show toplevel */

  if (g_list_next (selection) == NULL &&

      GTK_IS_WIDGET (selection->data) &&

      (layout = gtk_widget_get_ancestor (selection->data, GLADE_TYPE_DESIGN_LAYOUT)))

    {

      GtkAllocation alloc;

      gtk_widget_get_allocation (layout, &alloc);

      if (alloc.x < 0)

        g_signal_connect (layout, "size-allocate", G_CALLBACK (on_layout_size_allocate), view);

      else

        glade_design_layout_scroll (view, alloc.x, alloc.y, alloc.width, alloc.height);

    }

}

static void

glade_design_view_add_toplevel (GladeDesignView *view, GladeWidget *widget)

{

  GtkWidget *layout;

  GList *toplevels;

  GObject *object;

  if (glade_widget_get_parent (widget) ||

      (object = glade_widget_get_object (widget)) == NULL ||

      !GTK_IS_WIDGET (object) ||

      gtk_widget_get_parent (GTK_WIDGET (object)))

    return;

  /* Create a GladeDesignLayout and add the toplevel widget to the view */

  layout = _glade_design_layout_new (view);

  gtk_widget_set_halign (layout, GTK_ALIGN_START);

  gtk_box_pack_start (GTK_BOX (view->priv->layout_box), layout, FALSE, FALSE, 0);

  if ((toplevels = glade_project_toplevels (view->priv->project)))

    gtk_box_reorder_child (GTK_BOX (view->priv->layout_box), layout, 

                           g_list_index (toplevels, GTK_WIDGET (object)));

  gtk_container_add (GTK_CONTAINER (layout), GTK_WIDGET (object));

  gtk_widget_show (GTK_WIDGET (object));

  gtk_widget_show (layout);

}

static void

glade_design_view_remove_toplevel (GladeDesignView *view, GladeWidget *widget)

{

  GtkWidget *layout;

  GObject *object;

  if (glade_widget_get_parent (widget) ||

      (object = glade_widget_get_object (widget)) == NULL ||

      !GTK_IS_WIDGET (object)) return;

  /* Remove toplevel widget from the view */

  if ((layout = gtk_widget_get_parent (GTK_WIDGET (object))) &&

      gtk_widget_is_ancestor (layout, GTK_WIDGET (view)))

    {

      gtk_container_remove (GTK_CONTAINER (layout), GTK_WIDGET (object));

      gtk_container_remove (GTK_CONTAINER (view->priv->layout_box), layout);

    }

}

static void

glade_design_view_widget_visibility_changed (GladeProject    *project,

                                             GladeWidget     *widget,

                                             gboolean         visible,

                                             GladeDesignView *view)

{

  if (visible)

    glade_design_view_add_toplevel (view, widget);

  else

    glade_design_view_remove_toplevel (view, widget);

}

static void

on_project_add_widget (GladeProject *project, GladeWidget *widget, GladeDesignView *view)

{

  glade_design_view_add_toplevel (view, widget);

}

static void

on_project_remove_widget (GladeProject *project, GladeWidget *widget, GladeDesignView *view)

{

  glade_design_view_remove_toplevel (view, widget);

}

static void

glade_design_view_set_project (GladeDesignView *view, GladeProject *project)

{

  GladeDesignViewPrivate *priv;

  priv = view->priv;

  if (priv->project)

    {

      g_signal_handlers_disconnect_by_func (priv->project,

                                            on_project_add_widget,

                                            view);

      g_signal_handlers_disconnect_by_func (priv->project,

                                            on_project_remove_widget,

                                            view);

      g_signal_handlers_disconnect_by_func (priv->project,

                                            gtk_widget_hide,

                                            priv->scrolled_window);

      g_signal_handlers_disconnect_by_func (priv->project,

                                            gtk_widget_show,

                                            priv->scrolled_window);

      g_signal_handlers_disconnect_by_func (priv->project,

                                            glade_design_view_selection_changed,

                                            view);

      g_signal_handlers_disconnect_by_func (priv->project,

                                            glade_design_view_widget_visibility_changed,

                                            view);

      g_object_set_data (G_OBJECT (priv->project), GLADE_DESIGN_VIEW_KEY, NULL);

      g_clear_object (&priv->project);

    }

  if (!project)

    return;

  priv->project = g_object_ref (project);

  g_signal_connect (project, "add-widget",

                    G_CALLBACK (on_project_add_widget), view);

  g_signal_connect (project, "remove-widget",

                    G_CALLBACK (on_project_remove_widget), view);

  g_signal_connect_swapped (project, "parse-began",

                            G_CALLBACK (gtk_widget_hide),

                            priv->scrolled_window);

  g_signal_connect_swapped (project, "parse-finished",

                            G_CALLBACK (gtk_widget_show),

                            priv->scrolled_window);

  g_signal_connect (project, "selection-changed",

                    G_CALLBACK (glade_design_view_selection_changed), view);

  g_signal_connect (project, "widget-visibility-changed",

                    G_CALLBACK (glade_design_view_widget_visibility_changed), view);

  g_object_set_data (G_OBJECT (project), GLADE_DESIGN_VIEW_KEY, view);

}

static void

glade_design_view_set_property (GObject *object,

                                guint prop_id,

                                const GValue *value, GParamSpec *pspec)

{

  switch (prop_id)

    {

      case PROP_PROJECT:

        glade_design_view_set_project (GLADE_DESIGN_VIEW (object),

                                       g_value_get_object (value));

        break;

      default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

        break;

    }

}

static void

glade_design_view_get_property (GObject *object,

                                guint prop_id,

                                GValue *value,

                                GParamSpec *pspec)

{

  switch (prop_id)

    {

      case PROP_PROJECT:

        g_value_set_object (value, GLADE_DESIGN_VIEW (object)->priv->project);

        break;

      default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

        break;

    }

}

static void

logo_draw (GtkWidget *widget, cairo_t *cr, GdkRGBA *c)

{

  GtkAllocation alloc;

  gdouble scale;

  gtk_widget_get_allocation (widget, &alloc);

  cairo_save (cr);

  cairo_set_source_rgba (cr, c->red, c->green, c->blue, .06);

  scale = MIN ((alloc.width/1.5)/(glade_path_WIDTH), (alloc.height/1.5)/(glade_path_HEIGHT));

  cairo_scale (cr, scale, scale);

  cairo_translate (cr, (alloc.width / scale) - glade_path_WIDTH,

                   (alloc.height / scale) - glade_path_HEIGHT);

  cairo_append_path (cr, &glade_path);

  cairo_fill (cr);

  cairo_restore (cr);

}

static void

on_chooser_adaptor_widget_selected (_GladeAdaptorChooserWidget *chooser,

                                    GladeWidgetAdaptor         *adaptor,

                                    GladeProject               *project)

{

  glade_command_create (adaptor, NULL, NULL, project);

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

}

static gboolean

glade_design_view_viewport_button_press (GtkWidget       *widget,

                                         GdkEventButton  *event,

                                         GladeDesignView *view)

{

  GladeDesignViewPrivate *priv = view->priv;

  GdkRectangle rect = {event->x, event->y, 8, 8};

  GtkWidget *pop, *chooser;

  if (event->type != GDK_2BUTTON_PRESS)

    return FALSE;

  pop = gtk_popover_new (widget);

  gtk_popover_set_pointing_to (GTK_POPOVER (pop), &rect);

  gtk_popover_set_position (GTK_POPOVER (pop), GTK_POS_BOTTOM);

  chooser = _glade_adaptor_chooser_widget_new (GLADE_ADAPTOR_CHOOSER_WIDGET_TOPLEVEL |

                                               GLADE_ADAPTOR_CHOOSER_WIDGET_WIDGET |

                                               GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_DEPRECATED,

                                               priv->project);

  _glade_adaptor_chooser_widget_populate (GLADE_ADAPTOR_CHOOSER_WIDGET (chooser));

  g_signal_connect (chooser, "adaptor-selected",

                    G_CALLBACK (on_chooser_adaptor_widget_selected),

                    priv->project);

  gtk_container_add (GTK_CONTAINER (pop), chooser);

  gtk_widget_show (chooser);

  gtk_popover_popup (GTK_POPOVER (pop));

  return TRUE;

}

static gboolean

glade_design_view_viewport_draw (GtkWidget *widget, cairo_t *cr, GladeDesignView *view)

{

  GladeDesignViewPrivate *priv = GLADE_DESIGN_VIEW (view)->priv;

  GtkStyleContext *context = gtk_widget_get_style_context (widget);

  GdkRGBA fg_color;

  gtk_style_context_get_color (context, gtk_style_context_get_state (context),

                               &fg_color);

  logo_draw (widget, cr, &fg_color);

  if (priv->drag_highlight)

    {

      GdkRGBA c;

      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);

      cairo_set_line_width (cr, 2);

      gdk_cairo_set_source_rgba (cr, &c);

      cairo_rectangle (cr, 0, 0,

                       gtk_widget_get_allocated_width (widget),

                       gtk_widget_get_allocated_height (widget));

      cairo_stroke (cr);

    }

  return FALSE;

}

static void

glade_design_view_init (GladeDesignView *view)

{

  GtkWidget *viewport;

  view->priv = glade_design_view_get_instance_private (view);

  gtk_widget_set_no_show_all (GTK_WIDGET (view), TRUE);

  gtk_orientable_set_orientation (GTK_ORIENTABLE (view),

				  GTK_ORIENTATION_VERTICAL);

  view->priv->project = NULL;

  view->priv->layout_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);

  gtk_widget_set_valign (view->priv->layout_box, GTK_ALIGN_START);

  gtk_container_set_border_width (GTK_CONTAINER (view->priv->layout_box), 0);

  view->priv->scrolled_window = gtk_scrolled_window_new (NULL, NULL);

  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW

                                  (view->priv->scrolled_window),

                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

  viewport = gtk_viewport_new (NULL, NULL);

  gtk_widget_add_events (viewport, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);

  g_signal_connect (viewport, "button-press-event",

                    G_CALLBACK (glade_design_view_viewport_button_press),

                    view);

  g_signal_connect (viewport, "draw",

                    G_CALLBACK (glade_design_view_viewport_draw),

                    view);

  gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_NONE);

  gtk_container_add (GTK_CONTAINER (viewport), view->priv->layout_box);

  gtk_container_add (GTK_CONTAINER (view->priv->scrolled_window), viewport);

  gtk_widget_show (view->priv->scrolled_window);

  gtk_widget_show (viewport);

  gtk_widget_show_all (view->priv->layout_box);

  gtk_box_pack_start (GTK_BOX (view), view->priv->scrolled_window, TRUE, TRUE, 0);

  gtk_container_set_border_width (GTK_CONTAINER (view), 0);

  gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (view)),

                               GTK_STYLE_CLASS_VIEW);

  _glade_dnd_dest_set (GTK_WIDGET (view));

}

static void

glade_design_view_finalize (GObject *object)

{

  GladeDesignView *view = GLADE_DESIGN_VIEW (object);

  glade_design_view_set_project (view, NULL);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

typedef struct

{

  GtkWidget *child;

  gint x, y;

} FindInContainerData;

static void

find_inside_container (GtkWidget *widget, FindInContainerData *data)

{

  GtkAllocation alloc;

  gint x, y;

  if (data->child || !gtk_widget_get_mapped (widget))

    return;

  x = data->x;

  y = data->y;

  gtk_widget_get_allocation (widget, &alloc);

  if (x >= alloc.x && x <= (alloc.x + alloc.width) &&

      y >= alloc.y && y <= (alloc.y + alloc.height))

    {

      data->child = widget;

    }

}

static void

glade_design_view_drag_highlight (_GladeDrag *dest,

                                  gint       x,

                                  gint       y)

{

  if (GLADE_IS_WIDGET (dest))

    {

      GObject *obj = glade_widget_get_object (GLADE_WIDGET (dest));

      if (GTK_IS_WIDGET (obj))

        {

          GtkWidget *layout = gtk_widget_get_ancestor (GTK_WIDGET (obj),

                                                       GLADE_TYPE_DESIGN_LAYOUT);

          if (layout)

            _glade_design_layout_set_highlight (GLADE_DESIGN_LAYOUT (layout),

                                                (x<0 || y<0) ? NULL : GLADE_WIDGET (dest));

        }

    }

  _glade_drag_highlight (dest, x, y);

}

static gboolean

glade_design_view_drag_motion (GtkWidget *widget,

                               GdkDragContext *context,

                               gint x, gint y,

                               guint time)

{

  GladeDesignView *view = GLADE_DESIGN_VIEW (widget);

  GladeDesignViewPrivate *priv = view->priv;

  FindInContainerData data;

  _GladeDrag *drag = NULL;

  gint xx, yy;

  if (!priv->drag_data)

    {

      GdkAtom target = gtk_drag_dest_find_target (widget, context, NULL);

      if (target)

        gtk_drag_get_data (widget, context, target, time);

    }

  data.child = NULL;

  gtk_widget_translate_coordinates (widget, GTK_WIDGET (priv->layout_box),

                                    x, y, &data.x, &data.y);

  gtk_container_forall (GTK_CONTAINER (priv->layout_box),

                        (GtkCallback) find_inside_container,

                        &data);

  if (data.child)

    {

      GladeDesignLayout *layout = GLADE_DESIGN_LAYOUT (data.child);

      GladeWidget *gchild = _glade_design_layout_get_child (layout);

      GtkWidget *child = GTK_WIDGET (glade_widget_get_object (gchild));

      GtkWidget *drag_target;

      gtk_widget_translate_coordinates (widget, child, x, y, &xx, &yy;;

      drag_target = _glade_design_layout_get_child_at_position (child, xx, yy);

      if (drag_target)

        {

          GladeWidget *gwidget;

          if (GLADE_IS_PLACEHOLDER (drag_target))

            drag = GLADE_DRAG (drag_target);

          else if ((gwidget = glade_widget_get_from_gobject (drag_target)))

            {

              while (gwidget && !_glade_drag_can_drop (GLADE_DRAG (gwidget),

                                                       xx, yy, priv->drag_data))

                gwidget = glade_widget_get_parent (gwidget);

              if (gwidget)

                drag = GLADE_DRAG (gwidget);

            }

        }

    }

  else if (_glade_drag_can_drop (GLADE_DRAG (widget), x, y, priv->drag_data))

    {

      drag = GLADE_DRAG (widget);

      xx = x;

      yy = y;

    }

  if (priv->drag_target && priv->drag_target != drag)

    {

      glade_design_view_drag_highlight (priv->drag_target, -1, -1);

      g_clear_object (&priv->drag_target);

    }

  if (drag)

    {

      priv->drag_target = g_object_ref (drag);

      glade_design_view_drag_highlight (drag, xx, yy);

      gdk_drag_status (context, GDK_ACTION_COPY, time);

      return TRUE;

    }

  gdk_drag_status (context, 0, time);

  return FALSE;

}

static void

glade_design_view_drag_leave (GtkWidget      *widget,

                              GdkDragContext *context,

                              guint           time)

{

  GladeDesignViewPrivate *priv = GLADE_DESIGN_VIEW (widget)->priv;

  if (priv->drag_target)

    glade_design_view_drag_highlight (priv->drag_target, -1, -1);

}

static void

on_source_drag_end (GtkWidget       *widget,

                    GdkDragContext  *context, 

                    GladeDesignView *view)

{

  GladeDesignViewPrivate *priv = view->priv;

  if (priv->drag_target)

    {

      glade_design_view_drag_highlight (priv->drag_target, -1, -1);

      g_clear_object (&priv->drag_target);

    }

  g_clear_object (&priv->drag_data);

}

static void

glade_design_view_drag_data_received (GtkWidget        *widget,

                                      GdkDragContext   *context,

                                      gint              x,

                                      gint              y,

                                      GtkSelectionData *selection,

                                      guint             info,

                                      guint             time)

{

  GtkWidget *source = gtk_drag_get_source_widget (context);

  GladeDesignView *view = GLADE_DESIGN_VIEW (widget);

  GladeDesignViewPrivate *priv = view->priv;

  g_signal_handlers_disconnect_by_func (source, on_source_drag_end, view);

  g_clear_object (&priv->drag_data);

  priv->drag_data = _glade_dnd_get_data (context, selection, info);

  if (priv->drag_data)

    g_object_ref (priv->drag_data);

  g_signal_connect_object (source, "drag-end", G_CALLBACK (on_source_drag_end), view, 0);

}

static gboolean

glade_design_view_drag_drop (GtkWidget       *widget,

                             GdkDragContext  *context,

                             gint             x,

                             gint             y,

                             guint            time)  

{

  GladeDesignViewPrivate *priv = GLADE_DESIGN_VIEW (widget)->priv;

  if (priv->drag_data && priv->drag_target)

    {

      GtkWidget *target;

      gint xx, yy;

      if (GLADE_IS_WIDGET (priv->drag_target))

        target = GTK_WIDGET (glade_widget_get_object (GLADE_WIDGET (priv->drag_target)));

      else

        target = GTK_WIDGET (priv->drag_target);

      gtk_widget_translate_coordinates (widget, target, x, y, &xx, &yy;;

      _glade_drag_drop (GLADE_DRAG (priv->drag_target), xx, yy, priv->drag_data);

      gtk_drag_finish (context, TRUE, FALSE, time);

    }

  else

    gtk_drag_finish (context, FALSE, FALSE, time);

  return TRUE;

}

static gboolean

glade_design_view_drag_iface_can_drop (_GladeDrag *drag,

                                       gint x, gint y,

                                       GObject *data)

{

  GladeWidget *gwidget;

  if (GLADE_IS_WIDGET_ADAPTOR (data) ||

      ((gwidget = glade_widget_get_from_gobject (data)) &&

       glade_widget_get_parent (gwidget)))

    return TRUE;

  else

    return FALSE;

}

static gboolean

glade_design_view_drag_iface_drop (_GladeDrag *drag,

                                   gint x, gint y,

                                   GObject *data)

{

  GladeDesignViewPrivate *priv = GLADE_DESIGN_VIEW (drag)->priv;

  GladeWidget *gsource;

  if (GLADE_IS_WIDGET_ADAPTOR (data))

    {

      glade_command_create (GLADE_WIDGET_ADAPTOR (data),

                            NULL, NULL, priv->project);

      return TRUE;

    }

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

    {

      GList widgets = {gsource, NULL, NULL};

      glade_command_dnd (&widgets, NULL, NULL);

      return TRUE;

    }

  return FALSE;

}

static void

glade_design_view_drag_iface_highlight (_GladeDrag *drag, gint x, gint y)

{

  GladeDesignViewPrivate *priv = GLADE_DESIGN_VIEW (drag)->priv;

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

  if (priv->drag_highlight == highlight)

    return;

  priv->drag_highlight = highlight;

  gtk_widget_queue_draw (priv->scrolled_window);

}

static void

glade_design_view_drag_init (_GladeDragInterface *iface)

{

  iface->can_drag = NULL;

  iface->can_drop = glade_design_view_drag_iface_can_drop;

  iface->drop = glade_design_view_drag_iface_drop;

  iface->highlight = glade_design_view_drag_iface_highlight;

}

static void

glade_design_view_class_init (GladeDesignViewClass *klass)

{

  GObjectClass *object_class;

  GtkWidgetClass *widget_class;

  parent_class = g_type_class_peek_parent (klass);

  object_class = G_OBJECT_CLASS (klass);

  widget_class = GTK_WIDGET_CLASS (klass);

  object_class->finalize = glade_design_view_finalize;

  object_class->get_property = glade_design_view_get_property;

  object_class->set_property = glade_design_view_set_property;

  widget_class->drag_motion = glade_design_view_drag_motion;

  widget_class->drag_leave = glade_design_view_drag_leave;

  widget_class->drag_data_received = glade_design_view_drag_data_received;

  widget_class->drag_drop = glade_design_view_drag_drop;

  g_object_class_install_property (object_class,

                                   PROP_PROJECT,

                                   g_param_spec_object ("project",

                                                        "Project",

                                                        "The project for this view",

                                                        GLADE_TYPE_PROJECT,

                                                        G_PARAM_READWRITE |

                                                        G_PARAM_CONSTRUCT_ONLY));

}

/* Public API */

GladeProject *

glade_design_view_get_project (GladeDesignView *view)

{

  g_return_val_if_fail (GLADE_IS_DESIGN_VIEW (view), NULL);

  return view->priv->project;

}

GtkWidget *

glade_design_view_new (GladeProject *project)

{

  GladeDesignView *view;

  g_return_val_if_fail (GLADE_IS_PROJECT (project), NULL);

  view = g_object_new (GLADE_TYPE_DESIGN_VIEW, "project", project, NULL);

  return GTK_WIDGET (view);

}

GladeDesignView *

glade_design_view_get_from_project (GladeProject *project)

{

  gpointer p;

  g_return_val_if_fail (GLADE_IS_PROJECT (project), NULL);

  p = g_object_get_data (G_OBJECT (project), GLADE_DESIGN_VIEW_KEY);

  return (p != NULL) ? GLADE_DESIGN_VIEW (p) : NULL;

}