/* GIMP - The GNU Image Manipulation Program
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * gimpdock.c
 * Copyright (C) 2001-2018 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 <https://www.gnu.org/licenses/>.
 */

#include "config.h"

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

#include "libgimpwidgets/gimpwidgets.h"

#include "widgets-types.h"

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

#include "gimpdialogfactory.h"
#include "gimpdock.h"
#include "gimpdockable.h"
#include "gimpdockbook.h"
#include "gimpdockcolumns.h"
#include "gimpdockcontainer.h"
#include "gimpdockwindow.h"
#include "gimppanedbox.h"
#include "gimpuimanager.h"
#include "gimpwidgets-utils.h"

#include "gimp-intl.h"


enum
{
  BOOK_ADDED,
  BOOK_REMOVED,
  DESCRIPTION_INVALIDATED,
  GEOMETRY_INVALIDATED,
  LAST_SIGNAL
};


struct _GimpDockPrivate
{
  GtkWidget *main_vbox;
  GtkWidget *paned_vbox;

  GList     *dockbooks;

  gint       ID;
};


static void       gimp_dock_dispose                (GObject      *object);

static gchar    * gimp_dock_real_get_description   (GimpDock     *dock,
                                                    gboolean      complete);
static void       gimp_dock_real_book_added        (GimpDock     *dock,
                                                    GimpDockbook *dockbook);
static void       gimp_dock_real_book_removed      (GimpDock     *dock,
                                                    GimpDockbook *dockbook);
static void       gimp_dock_invalidate_description (GimpDock     *dock);
static gboolean   gimp_dock_dropped_cb             (GtkWidget    *notebook,
                                                    GtkWidget    *child,
                                                    gint          insert_index,
                                                    gpointer      data);


G_DEFINE_TYPE_WITH_PRIVATE (GimpDock, gimp_dock, GTK_TYPE_BOX)

#define parent_class gimp_dock_parent_class

static guint dock_signals[LAST_SIGNAL] = { 0 };


static void
gimp_dock_class_init (GimpDockClass *klass)
{
  GObjectClass   *object_class = G_OBJECT_CLASS (klass);
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);

  dock_signals[BOOK_ADDED] =
    g_signal_new ("book-added",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (GimpDockClass, book_added),
                  NULL, NULL,
                  gimp_marshal_VOID__OBJECT,
                  G_TYPE_NONE, 1,
                  GIMP_TYPE_DOCKBOOK);

  dock_signals[BOOK_REMOVED] =
    g_signal_new ("book-removed",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (GimpDockClass, book_removed),
                  NULL, NULL,
                  gimp_marshal_VOID__OBJECT,
                  G_TYPE_NONE, 1,
                  GIMP_TYPE_DOCKBOOK);

  dock_signals[DESCRIPTION_INVALIDATED] =
    g_signal_new ("description-invalidated",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (GimpDockClass, description_invalidated),
                  NULL, NULL,
                  gimp_marshal_VOID__VOID,
                  G_TYPE_NONE, 0);

  dock_signals[GEOMETRY_INVALIDATED] =
    g_signal_new ("geometry-invalidated",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (GimpDockClass, geometry_invalidated),
                  NULL, NULL,
                  gimp_marshal_VOID__VOID,
                  G_TYPE_NONE, 0);

  object_class->dispose          = gimp_dock_dispose;

  klass->get_description         = gimp_dock_real_get_description;
  klass->set_host_geometry_hints = NULL;
  klass->book_added              = gimp_dock_real_book_added;
  klass->book_removed            = gimp_dock_real_book_removed;
  klass->description_invalidated = NULL;
  klass->geometry_invalidated    = NULL;

  gtk_widget_class_set_css_name (widget_class, "GimpDock");
}

static void
gimp_dock_init (GimpDock *dock)
{
  static gint  dock_ID = 1;
  gchar       *name    = NULL;

  gtk_orientable_set_orientation (GTK_ORIENTABLE (dock),
                                  GTK_ORIENTATION_VERTICAL);

  dock->p = gimp_dock_get_instance_private (dock);
  dock->p->ID = dock_ID++;

  name = g_strdup_printf ("gimp-internal-dock-%d", dock->p->ID);
  gtk_widget_set_name (GTK_WIDGET (dock), name);
  g_free (name);

  dock->p->main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
  gtk_box_pack_start (GTK_BOX (dock), dock->p->main_vbox, TRUE, TRUE, 0);
  gtk_widget_show (dock->p->main_vbox);

  dock->p->paned_vbox = gimp_paned_box_new (FALSE, 0, GTK_ORIENTATION_VERTICAL);
  gimp_paned_box_set_dropped_cb (GIMP_PANED_BOX (dock->p->paned_vbox),
                                 gimp_dock_dropped_cb,
                                 dock);
  gtk_box_pack_start (GTK_BOX (dock->p->main_vbox), dock->p->paned_vbox,
                      TRUE, TRUE, 0);
  gtk_widget_show (dock->p->paned_vbox);
}

static void
gimp_dock_dispose (GObject *object)
{
  GimpDock *dock = GIMP_DOCK (object);

  while (dock->p->dockbooks)
    {
      GimpDockbook *dockbook = dock->p->dockbooks->data;

      g_object_ref (dockbook);
      gimp_dock_remove_book (dock, dockbook);
      gtk_widget_destroy (GTK_WIDGET (dockbook));
      g_object_unref (dockbook);
    }

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

static gchar *
gimp_dock_real_get_description (GimpDock *dock,
                                gboolean  complete)
{
  GString *desc;
  GList   *list;

  desc = g_string_new (NULL);

  for (list = gimp_dock_get_dockbooks (dock);
       list;
       list = g_list_next (list))
    {
      GimpDockbook *dockbook = list->data;
      GList        *children;
      GList        *child;

      if (complete)
        {
          /* Include all dockables */
          children = gtk_container_get_children (GTK_CONTAINER (dockbook));
        }
      else
        {
          GtkWidget *dockable = NULL;
          gint       page_num = 0;

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

          /* Only include active dockables */
          children = g_list_append (NULL, dockable);
        }

      for (child = children; child; child = g_list_next (child))
        {
          GimpDockable *dockable = child->data;

          g_string_append (desc, gimp_dockable_get_name (dockable));

          if (g_list_next (child))
            g_string_append (desc, GIMP_DOCK_DOCKABLE_SEPARATOR);
        }

      g_list_free (children);

      if (g_list_next (list))
        g_string_append (desc, GIMP_DOCK_BOOK_SEPARATOR);
    }

  return g_string_free (desc, FALSE);
}

static void
gimp_dock_real_book_added (GimpDock     *dock,
                           GimpDockbook *dockbook)
{
  g_signal_connect_object (dockbook, "switch-page",
                           G_CALLBACK (gimp_dock_invalidate_description),
                           dock, G_CONNECT_SWAPPED);
}

static void
gimp_dock_real_book_removed (GimpDock     *dock,
                             GimpDockbook *dockbook)
{
  g_signal_handlers_disconnect_by_func (dockbook,
                                        gimp_dock_invalidate_description,
                                        dock);
}

static void
gimp_dock_invalidate_description (GimpDock *dock)
{
  g_return_if_fail (GIMP_IS_DOCK (dock));

  g_signal_emit (dock, dock_signals[DESCRIPTION_INVALIDATED], 0);
}

static gboolean
gimp_dock_dropped_cb (GtkWidget *notebook,
                      GtkWidget *child,
                      gint       insert_index,
                      gpointer   data)
{
  GimpDock          *dock     = GIMP_DOCK (data);
  GimpDockbook      *dockbook = GIMP_DOCKBOOK (notebook);
  GimpDockable      *dockable = GIMP_DOCKABLE (child);
  GimpDialogFactory *factory;
  GtkWidget         *new_dockbook;

  /*  if dropping to the same dock, take care that we don't try
   *  to reorder the *only* dockable in the dock
   */
  if (gimp_dockbook_get_dock (dockbook) == dock)
    {
      GList *children    = gtk_container_get_children (GTK_CONTAINER (dockable));
      gint   n_dockables = g_list_length (children);
      gint   n_books     = g_list_length (gimp_dock_get_dockbooks (dock));

      g_list_free (children);

      if (n_books == 1 && n_dockables == 1)
        return TRUE; /* successfully do nothing */
    }

  /* Detach the dockable from the old dockbook */
  g_object_ref (dockable);
  gtk_notebook_detach_tab (GTK_NOTEBOOK (notebook), child);

  /* Create a new dockbook */
  factory = gimp_dock_get_dialog_factory (dock);
  new_dockbook = gimp_dockbook_new (gimp_dialog_factory_get_menu_factory (factory));
  gimp_dock_add_book (dock, GIMP_DOCKBOOK (new_dockbook), insert_index);

  /* Add the dockable to new new dockbook */
  gtk_notebook_append_page (GTK_NOTEBOOK (new_dockbook), child, NULL);
  g_object_unref (dockable);

  return TRUE;
}


/*  public functions  */

/**
 * gimp_dock_get_description:
 * @dock:
 * @complete: If %TRUE, only includes the active dockables, i.e. not the
 *            dockables in a non-active GtkNotebook tab
 *
 * Returns: A string describing the contents of the dock.
 **/
gchar *
gimp_dock_get_description (GimpDock *dock,
                           gboolean  complete)
{
  g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);

  if (GIMP_DOCK_GET_CLASS (dock)->get_description)
    return GIMP_DOCK_GET_CLASS (dock)->get_description (dock, complete);

  return NULL;
}

/**
 * gimp_dock_set_host_geometry_hints:
 * @dock:   The dock
 * @window: The #GtkWindow to adapt to hosting the dock
 *
 * Some docks have some specific needs on the #GtkWindow they are
 * in. This function allows such docks to perform any such setup on
 * the #GtkWindow they are in/will be put in.
 **/
void
gimp_dock_set_host_geometry_hints (GimpDock  *dock,
                                   GtkWindow *window)
{
  g_return_if_fail (GIMP_IS_DOCK (dock));
  g_return_if_fail (GTK_IS_WINDOW (window));

  if (GIMP_DOCK_GET_CLASS (dock)->set_host_geometry_hints)
    GIMP_DOCK_GET_CLASS (dock)->set_host_geometry_hints (dock, window);
}

/**
 * gimp_dock_invalidate_geometry:
 * @dock:
 *
 * Call when the dock needs to setup its host #GtkWindow with
 * GtkDock::set_host_geometry_hints().
 **/
void
gimp_dock_invalidate_geometry (GimpDock *dock)
{
  g_return_if_fail (GIMP_IS_DOCK (dock));

  g_signal_emit (dock, dock_signals[GEOMETRY_INVALIDATED], 0);
}

/**
 * gimp_dock_update_with_context:
 * @dock:
 * @context:
 *
 * Set the @context on all dockables in the @dock.
 **/
void
gimp_dock_update_with_context (GimpDock    *dock,
                               GimpContext *context)
{
  GList *iter = NULL;

  for (iter = gimp_dock_get_dockbooks (dock);
       iter;
       iter = g_list_next (iter))
    {
      GimpDockbook *dockbook = GIMP_DOCKBOOK (iter->data);

      gimp_dockbook_update_with_context (dockbook, context);
    }
}

/**
 * gimp_dock_get_context:
 * @dock:
 *
 * Returns: The #GimpContext for the #GimpDockWindow the @dock is in.
 **/
GimpContext *
gimp_dock_get_context (GimpDock *dock)
{
  GimpContext *context = NULL;

  g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);

  /* First try GimpDockColumns */
  if (! context)
    {
      GimpDockColumns *dock_columns;

      dock_columns =
        GIMP_DOCK_COLUMNS (gtk_widget_get_ancestor (GTK_WIDGET (dock),
                                                    GIMP_TYPE_DOCK_COLUMNS));

      if (dock_columns)
        context = gimp_dock_columns_get_context (dock_columns);
    }

  /* Then GimpDockWindow */
  if (! context)
    {
      GimpDockWindow *dock_window = gimp_dock_window_from_dock (dock);

      if (dock_window)
        context = gimp_dock_window_get_context (dock_window);
    }

  return context;
}

/**
 * gimp_dock_get_dialog_factory:
 * @dock:
 *
 * Returns: The #GimpDialogFactory for the #GimpDockWindow the @dock
 *          is in.
 **/
GimpDialogFactory *
gimp_dock_get_dialog_factory (GimpDock *dock)
{
  GimpDialogFactory *dialog_factory = NULL;

  g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);

  /* First try GimpDockColumns */
  if (! dialog_factory)
    {
      GimpDockColumns *dock_columns;

      dock_columns =
        GIMP_DOCK_COLUMNS (gtk_widget_get_ancestor (GTK_WIDGET (dock),
                                                    GIMP_TYPE_DOCK_COLUMNS));

      if (dock_columns)
        dialog_factory = gimp_dock_columns_get_dialog_factory (dock_columns);
    }

  /* Then GimpDockWindow */
  if (! dialog_factory)
    {
      GimpDockWindow *dock_window = gimp_dock_window_from_dock (dock);

      if (dock_window)
        dialog_factory = gimp_dock_container_get_dialog_factory (GIMP_DOCK_CONTAINER (dock_window));
    }

  return dialog_factory;
}

/**
 * gimp_dock_get_ui_manager:
 * @dock:
 *
 * Returns: The #GimpUIManager for the #GimpDockWindow the @dock is
 *          in.
 **/
GimpUIManager *
gimp_dock_get_ui_manager (GimpDock *dock)
{
  GimpUIManager *ui_manager = NULL;

  g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);

  /* First try GimpDockColumns */
  if (! ui_manager)
    {
      GimpDockColumns *dock_columns;

      dock_columns =
        GIMP_DOCK_COLUMNS (gtk_widget_get_ancestor (GTK_WIDGET (dock),
                                                    GIMP_TYPE_DOCK_COLUMNS));

      if (dock_columns)
        ui_manager = gimp_dock_columns_get_ui_manager (dock_columns);
    }

  /* Then GimpDockContainer */
  if (! ui_manager)
    {
      GimpDockWindow *dock_window = gimp_dock_window_from_dock (dock);

      if (dock_window)
        {
          GimpDockContainer *dock_container = GIMP_DOCK_CONTAINER (dock_window);

          ui_manager = gimp_dock_container_get_ui_manager (dock_container);
        }
    }

  return ui_manager;
}

GList *
gimp_dock_get_dockbooks (GimpDock *dock)
{
  g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);

  return dock->p->dockbooks;
}

gint
gimp_dock_get_n_dockables (GimpDock *dock)
{
  GList *list = NULL;
  gint   n    = 0;

  g_return_val_if_fail (GIMP_IS_DOCK (dock), 0);

  for (list = dock->p->dockbooks; list; list = list->next)
    n += gtk_notebook_get_n_pages (GTK_NOTEBOOK (list->data));

  return n;
}

GtkWidget *
gimp_dock_get_main_vbox (GimpDock *dock)
{
  g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);

  return dock->p->main_vbox;
}

GtkWidget *
gimp_dock_get_vbox (GimpDock *dock)
{
  g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);

  return dock->p->paned_vbox;
}

void
gimp_dock_set_id (GimpDock *dock,
                  gint      ID)
{
  g_return_if_fail (GIMP_IS_DOCK (dock));

  dock->p->ID = ID;
}

gint
gimp_dock_get_id (GimpDock *dock)
{
  g_return_val_if_fail (GIMP_IS_DOCK (dock), 0);

  return dock->p->ID;
}

void
gimp_dock_add_book (GimpDock     *dock,
                    GimpDockbook *dockbook,
                    gint          index)
{
  g_return_if_fail (GIMP_IS_DOCK (dock));
  g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
  g_return_if_fail (gimp_dockbook_get_dock (dockbook) == NULL);

  gimp_dockbook_set_dock (dockbook, dock);

  g_signal_connect_object (dockbook, "dockable-added",
                           G_CALLBACK (gimp_dock_invalidate_description),
                           dock, G_CONNECT_SWAPPED);
  g_signal_connect_object (dockbook, "dockable-removed",
                           G_CALLBACK (gimp_dock_invalidate_description),
                           dock, G_CONNECT_SWAPPED);
  g_signal_connect_object (dockbook, "dockable-reordered",
                           G_CALLBACK (gimp_dock_invalidate_description),
                           dock, G_CONNECT_SWAPPED);

  dock->p->dockbooks = g_list_insert (dock->p->dockbooks, dockbook, index);
  gimp_paned_box_add_widget (GIMP_PANED_BOX (dock->p->paned_vbox),
                             GTK_WIDGET (dockbook),
                             index);
  gtk_widget_show (GTK_WIDGET (dockbook));

  gimp_dock_invalidate_description (dock);

  g_signal_emit (dock, dock_signals[BOOK_ADDED], 0, dockbook);
}

void
gimp_dock_remove_book (GimpDock     *dock,
                       GimpDockbook *dockbook)
{
  g_return_if_fail (GIMP_IS_DOCK (dock));
  g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
  g_return_if_fail (gimp_dockbook_get_dock (dockbook) == dock);

  gimp_dockbook_set_dock (dockbook, NULL);

  g_signal_handlers_disconnect_by_func (dockbook,
                                        gimp_dock_invalidate_description,
                                        dock);

  /* Ref the dockbook so we can emit the "book-removed" signal and
   * pass it as a parameter before it's destroyed
   */
  g_object_ref (dockbook);

  dock->p->dockbooks = g_list_remove (dock->p->dockbooks, dockbook);
  gimp_paned_box_remove_widget (GIMP_PANED_BOX (dock->p->paned_vbox),
                                GTK_WIDGET (dockbook));

  gimp_dock_invalidate_description (dock);

  g_signal_emit (dock, dock_signals[BOOK_REMOVED], 0, dockbook);

  g_object_unref (dockbook);
}
