/* 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
 *
 * pikatoolbutton.c
 * Copyright (C) 2020 Ell
 *
 * 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 <string.h>

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

#include "libpikabase/pikabase.h"
#include "libpikamath/pikamath.h"
#include "libpikawidgets/pikawidgets.h"
#include "libpikawidgets/pikawidgets-private.h"

#include "widgets-types.h"

#include "core/pika.h"
#include "core/pika-gui.h"
#include "core/pikacontainer.h"
#include "core/pikacontext.h"
#include "core/pikadisplay.h"
#include "core/pikatoolgroup.h"
#include "core/pikatoolinfo.h"

#include "actions/tools-commands.h"

#include "pikaaccellabel.h"
#include "pikaaction.h"
#include "pikadock.h"
#include "pikatoolbox.h"
#include "pikatoolbutton.h"
#include "pikawidgets-utils.h"
#include "pikawindowstrategy.h"

#include "pika-intl.h"


#define ARROW_SIZE   0.125 /* * 100%       */
#define ARROW_BORDER 3     /* px           */

#define MENU_TIMEOUT 250   /* milliseconds */


enum
{
  PROP_0,
  PROP_TOOLBOX,
  PROP_TOOL_ITEM
};


struct _PikaToolButtonPrivate
{
  PikaToolbox  *toolbox;
  PikaToolItem *tool_item;

  GtkWidget    *palette;

  GtkWidget    *tooltip_widget;

  GtkWidget    *menu;
  GHashTable   *menu_items;
  gint          menu_timeout_id;
  GdkEvent     *menu_timeout_event;
};


/*  local function prototypes  */

static void         pika_tool_button_constructed         (GObject             *object);
static void         pika_tool_button_dispose             (GObject             *object);
static void         pika_tool_button_set_property        (GObject             *object,
                                                          guint                property_id,
                                                          const GValue        *value,
                                                          GParamSpec          *pspec);
static void         pika_tool_button_get_property        (GObject             *object,
                                                          guint                property_id,
                                                          GValue              *value,
                                                          GParamSpec          *pspec);

static void         pika_tool_button_hierarchy_changed   (GtkWidget           *widget,
                                                          GtkWidget           *previous_toplevel);
static gboolean     pika_tool_button_draw                (GtkWidget           *widget,
                                                          cairo_t             *cr);
static gboolean     pika_tool_button_query_tooltip       (GtkWidget           *widget,
                                                          gint                 x,
                                                          gint                 y,
                                                          gboolean             keyboard_mode,
                                                          GtkTooltip          *tooltip);

static void         pika_tool_button_toggled             (GtkToggleToolButton *toggle_tool_button);

static gboolean     pika_tool_button_button_press        (GtkWidget           *widget,
                                                          GdkEventButton      *event,
                                                          PikaToolButton      *tool_button);
static gboolean     pika_tool_button_button_release      (GtkWidget           *widget,
                                                          GdkEventButton      *event,
                                                          PikaToolButton      *tool_button);
static gboolean     pika_tool_button_scroll              (GtkWidget           *widget,
                                                          GdkEventScroll      *event,
                                                          PikaToolButton      *tool_button);

static void         pika_tool_button_tool_changed        (PikaContext         *context,
                                                          PikaToolInfo        *tool_info,
                                                          PikaToolButton      *tool_button);

static void         pika_tool_button_active_tool_changed (PikaToolGroup       *tool_group,
                                                          PikaToolButton      *tool_button);

static void         pika_tool_button_tool_add            (PikaContainer       *container,
                                                          PikaToolInfo        *tool_info,
                                                          PikaToolButton      *tool_button);
static void         pika_tool_button_tool_remove         (PikaContainer       *container,
                                                          PikaToolInfo        *tool_info,
                                                          PikaToolButton      *tool_button);
static void         pika_tool_button_tool_reorder        (PikaContainer       *container,
                                                          PikaToolInfo        *tool_info,
                                                          gint                 new_index,
                                                          PikaToolButton      *tool_button);

static void         pika_tool_button_icon_size_notify    (GtkToolPalette      *palette,
                                                          const GParamSpec    *pspec,
                                                          PikaToolButton      *tool_button);

static void         pika_tool_button_menu_item_activate  (GtkMenuItem         *menu_item,
                                                          PikaAction          *action);

static gboolean     pika_tool_button_menu_leave_notify   (GtkMenu             *menu,
                                                          GdkEventCrossing    *event,
                                                          PikaToolButton      *tool_button);

static gboolean     pika_tool_button_menu_timeout        (PikaToolButton      *tool_button);

static void         pika_tool_button_update              (PikaToolButton      *tool_button);
static void         pika_tool_button_update_toggled      (PikaToolButton      *tool_button);
static void         pika_tool_button_update_menu         (PikaToolButton      *tool_button);

static void         pika_tool_button_add_menu_item       (PikaToolButton      *tool_button,
                                                          PikaToolInfo        *tool_info,
                                                          gint                 index);
static void         pika_tool_button_remove_menu_item    (PikaToolButton      *tool_button,
                                                          PikaToolInfo        *tool_info);

static void         pika_tool_button_reconstruct_menu    (PikaToolButton      *tool_button);
static void         pika_tool_button_destroy_menu        (PikaToolButton      *tool_button);
static gboolean     pika_tool_button_show_menu           (PikaToolButton      *tool_button,
                                                          const GdkEvent      *trigger_event);

static PikaAction * pika_tool_button_get_action          (PikaToolButton      *tool_button,
                                                          PikaToolInfo        *tool_info);


G_DEFINE_TYPE_WITH_PRIVATE (PikaToolButton, pika_tool_button,
                            GTK_TYPE_TOGGLE_TOOL_BUTTON)

#define parent_class pika_tool_button_parent_class


/*  private functions  */

static void
pika_tool_button_class_init (PikaToolButtonClass *klass)
{
  GObjectClass             *object_class             = G_OBJECT_CLASS (klass);
  GtkWidgetClass           *widget_class             = GTK_WIDGET_CLASS (klass);
  GtkToggleToolButtonClass *toggle_tool_button_class = GTK_TOGGLE_TOOL_BUTTON_CLASS (klass);

  object_class->constructed         = pika_tool_button_constructed;
  object_class->dispose             = pika_tool_button_dispose;
  object_class->get_property        = pika_tool_button_get_property;
  object_class->set_property        = pika_tool_button_set_property;

  widget_class->hierarchy_changed   = pika_tool_button_hierarchy_changed;
  widget_class->draw                = pika_tool_button_draw;
  widget_class->query_tooltip       = pika_tool_button_query_tooltip;

  toggle_tool_button_class->toggled = pika_tool_button_toggled;

  g_object_class_install_property (object_class, PROP_TOOLBOX,
                                   g_param_spec_object ("toolbox",
                                                        NULL, NULL,
                                                        PIKA_TYPE_TOOLBOX,
                                                        PIKA_PARAM_READWRITE |
                                                        G_PARAM_CONSTRUCT_ONLY));

  g_object_class_install_property (object_class, PROP_TOOL_ITEM,
                                   g_param_spec_object ("tool-item",
                                                        NULL, NULL,
                                                        PIKA_TYPE_TOOL_ITEM,
                                                        PIKA_PARAM_READWRITE));
}

static void
pika_tool_button_init (PikaToolButton *tool_button)
{
  tool_button->priv = pika_tool_button_get_instance_private (tool_button);
}

static void
pika_tool_button_constructed (GObject *object)
{
  PikaToolButton *tool_button = PIKA_TOOL_BUTTON (object);
  PikaContext    *context;

  G_OBJECT_CLASS (parent_class)->constructed (object);

  context = pika_toolbox_get_context (tool_button->priv->toolbox);

  /* Make sure the toolbox buttons won't grab focus, which has
   * nearly no practical use, and prevents various actions until
   * you click back in canvas.
   */
  gtk_widget_set_can_focus (gtk_bin_get_child (GTK_BIN (tool_button)), FALSE);

  gtk_widget_add_events (gtk_bin_get_child (GTK_BIN (tool_button)),
                         GDK_SCROLL_MASK);

  g_signal_connect (gtk_bin_get_child (GTK_BIN (tool_button)),
                    "button-press-event",
                    G_CALLBACK (pika_tool_button_button_press),
                    tool_button);
  g_signal_connect (gtk_bin_get_child (GTK_BIN (tool_button)),
                    "button-release-event",
                    G_CALLBACK (pika_tool_button_button_release),
                    tool_button);
  g_signal_connect (gtk_bin_get_child (GTK_BIN (tool_button)),
                    "scroll-event",
                    G_CALLBACK (pika_tool_button_scroll),
                    tool_button);

  g_signal_connect_object (context, "tool-changed",
                           G_CALLBACK (pika_tool_button_tool_changed),
                           tool_button,
                           0);

  pika_tool_button_update (tool_button);
}

static void
pika_tool_button_dispose (GObject *object)
{
  PikaToolButton *tool_button = PIKA_TOOL_BUTTON (object);

  pika_tool_button_set_tool_item (tool_button, NULL);

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

static void
pika_tool_button_set_property (GObject      *object,
                               guint         property_id,
                               const GValue *value,
                               GParamSpec   *pspec)
{
  PikaToolButton *tool_button = PIKA_TOOL_BUTTON (object);

  switch (property_id)
    {
    case PROP_TOOLBOX:
      tool_button->priv->toolbox = g_value_get_object (value);
      break;

    case PROP_TOOL_ITEM:
      pika_tool_button_set_tool_item (tool_button, g_value_get_object (value));
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
      break;
    }
}

static void
pika_tool_button_get_property (GObject    *object,
                               guint       property_id,
                               GValue     *value,
                               GParamSpec *pspec)
{
  PikaToolButton *tool_button = PIKA_TOOL_BUTTON (object);

  switch (property_id)
    {
    case PROP_TOOLBOX:
      g_value_set_object (value, tool_button->priv->toolbox);
      break;

    case PROP_TOOL_ITEM:
      g_value_set_object (value, tool_button->priv->tool_item);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
      break;
    }
}

static void
pika_tool_button_hierarchy_changed (GtkWidget *widget,
                                    GtkWidget *previous_toplevel)
{
  PikaToolButton *tool_button = PIKA_TOOL_BUTTON (widget);
  GtkWidget      *palette;

  if (GTK_WIDGET_CLASS (parent_class)->hierarchy_changed)
    {
      GTK_WIDGET_CLASS (parent_class)->hierarchy_changed (widget,
                                                          previous_toplevel);
    }

  palette = gtk_widget_get_ancestor (GTK_WIDGET (tool_button),
                                     GTK_TYPE_TOOL_PALETTE);

  if (palette != tool_button->priv->palette)
    {
      if (tool_button->priv->palette)
        {
          g_signal_handlers_disconnect_by_func (
            tool_button->priv->palette,
            pika_tool_button_icon_size_notify,
            tool_button);
        }

      tool_button->priv->palette = palette;

      if (tool_button->priv->palette)
        {
          g_signal_connect (
            tool_button->priv->palette, "notify::icon-size",
            G_CALLBACK (pika_tool_button_icon_size_notify),
            tool_button);
        }
    }

  pika_tool_button_update (tool_button);

  pika_tool_button_reconstruct_menu (tool_button);
}

static gboolean
pika_tool_button_draw (GtkWidget *widget,
                       cairo_t   *cr)
{
  PikaToolButton *tool_button = PIKA_TOOL_BUTTON (widget);

  if (GTK_WIDGET_CLASS (parent_class)->draw)
    GTK_WIDGET_CLASS (parent_class)->draw (widget, cr);

  if (PIKA_IS_TOOL_GROUP (tool_button->priv->tool_item))
    {
      GtkStyleContext *style = gtk_widget_get_style_context (widget);
      GtkStateFlags    state = gtk_widget_get_state_flags (widget);
      GdkRGBA          fg;
      GtkAllocation    allocation;
      gint             size;
      gint             x1, y1;
      gint             x2, y2;

      gtk_style_context_get_color (style, state, &fg);

      gtk_widget_get_allocation (widget, &allocation);

      size = MIN (allocation.width, allocation.height);

      x1 = SIGNED_ROUND (allocation.width  -
                         (ARROW_BORDER + size * ARROW_SIZE));
      y1 = SIGNED_ROUND (allocation.height -
                         (ARROW_BORDER + size * ARROW_SIZE));

      x2 = SIGNED_ROUND (allocation.width  - ARROW_BORDER);
      y2 = SIGNED_ROUND (allocation.height - ARROW_BORDER);

      cairo_save (cr);

      cairo_move_to (cr, x2, y1);
      cairo_line_to (cr, x2, y2);
      cairo_line_to (cr, x1, y2);
      cairo_close_path (cr);

      gdk_cairo_set_source_rgba (cr, &fg);
      cairo_fill (cr);

      cairo_restore (cr);
    }

  return FALSE;
}

static GtkWidget *
pika_tool_button_query_tooltip_add_tool (PikaToolButton *tool_button,
                                         GtkGrid        *grid,
                                         gint            row,
                                         PikaToolInfo   *tool_info,
                                         const gchar    *label_str,
                                         GtkIconSize     icon_size)
{
  Pika        *pika;
  PikaAction  *action = NULL;
  GtkWidget   *label;
  GtkWidget   *image;
  gchar       *name;

  pika = pika_toolbox_get_context (tool_button->priv->toolbox)->pika;
  name = pika_tool_info_get_action_name (tool_info);

  action = PIKA_ACTION (g_action_map_lookup_action (G_ACTION_MAP (pika->app), name));
  g_free (name);

  image = gtk_image_new_from_icon_name (
    pika_viewable_get_icon_name (PIKA_VIEWABLE (tool_info)),
    icon_size);
  gtk_grid_attach (grid,
                   image,
                   0, row,
                   1, 1);
  gtk_widget_show (image);

  label = gtk_label_new (label_str);
  gtk_label_set_xalign (GTK_LABEL (label), 0.0);
  gtk_grid_attach (grid,
                   label,
                   1, row,
                   1, 1);
  gtk_widget_show (label);

  if (action)
    {
      GtkWidget *accel_label;

      accel_label = pika_accel_label_new (action);
      gtk_widget_set_margin_start (accel_label, 16);
      gtk_label_set_xalign (GTK_LABEL (accel_label), 1.0);
      gtk_grid_attach (grid,
                       accel_label,
                       2, row,
                       1, 1);
      gtk_widget_show (accel_label);
    }

  return label;
}

static gboolean
pika_tool_button_query_tooltip (GtkWidget  *widget,
                                gint        x,
                                gint        y,
                                gboolean    keyboard_mode,
                                GtkTooltip *tooltip)
{
  PikaToolButton *tool_button = PIKA_TOOL_BUTTON (widget);

  if (! tool_button->priv->tooltip_widget)
    {
      PikaToolInfo  *tool_info;
      GtkWidget     *grid;
      GtkWidget     *label;
      gchar        **tooltip_labels;
      GtkIconSize    icon_size = GTK_ICON_SIZE_MENU;
      gint           row       = 0;

      tool_info = pika_tool_button_get_tool_info (tool_button);

      if (! tool_info)
        return FALSE;

      if (tool_button->priv->palette)
        {
          icon_size = gtk_tool_palette_get_icon_size (
            GTK_TOOL_PALETTE (tool_button->priv->palette));
        }

      grid = gtk_grid_new ();
      gtk_grid_set_column_spacing (GTK_GRID (grid), 4);
      gtk_widget_show (grid);

      tool_button->priv->tooltip_widget = g_object_ref_sink (grid);

      tooltip_labels = g_strsplit (tool_info->tooltip, ": ", 2);

      label = pika_tool_button_query_tooltip_add_tool (tool_button,
                                                       GTK_GRID (grid),
                                                       row++,
                                                       tool_info,
                                                       tooltip_labels[0],
                                                       icon_size);
      pika_label_set_attributes (GTK_LABEL (label),
                                 PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD,
                                 -1);

      if (tooltip_labels[0])
        {
          //gtk_table_set_row_spacing (GTK_TABLE (table), 0, 0);

          label = gtk_label_new (tooltip_labels[1]);
          gtk_label_set_xalign (GTK_LABEL (label), 0.0);
          gtk_grid_attach (GTK_GRID (grid),
                           label,
                           1, row++,
                           1, 1);
          gtk_widget_show (label);
        }

      g_strfreev (tooltip_labels);

      if (PIKA_IS_TOOL_GROUP (tool_button->priv->tool_item))
        {
          PikaContainer *children;
          gint           n_children;

          children = pika_viewable_get_children (
            PIKA_VIEWABLE (tool_button->priv->tool_item));

          n_children = pika_container_get_n_children (children);

          if (n_children > 1)
            {
              GtkWidget *label;
              gint       i;

              label = gtk_label_new (_("Also in group:"));
              gtk_widget_set_margin_top (label, 4);
              gtk_label_set_xalign (GTK_LABEL (label), 0.0);
              pika_label_set_attributes (GTK_LABEL (label),
                                         PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD,
                                         -1);
              gtk_grid_attach (GTK_GRID (grid),
                               label,
                               0, row++,
                               3, 1);
              gtk_widget_show (label);

              for (i = 0; i < n_children; i++)
                {
                  PikaToolInfo *other_tool_info;

                  other_tool_info = PIKA_TOOL_INFO (
                    pika_container_get_child_by_index (children, i));

                  if (other_tool_info != tool_info)
                    {
                      pika_tool_button_query_tooltip_add_tool (
                        tool_button,
                        GTK_GRID (grid),
                        row++,
                        other_tool_info,
                        other_tool_info->label,
                        icon_size);
                    }
                }
            }
        }
    }

  gtk_tooltip_set_custom (tooltip, tool_button->priv->tooltip_widget);

  return TRUE;
}

static void
pika_tool_button_toggled (GtkToggleToolButton *toggle_tool_button)
{
  PikaToolButton *tool_button = PIKA_TOOL_BUTTON (toggle_tool_button);
  PikaContext    *context;
  PikaToolInfo   *tool_info;

  if (GTK_TOGGLE_TOOL_BUTTON_CLASS (parent_class)->toggled)
    GTK_TOGGLE_TOOL_BUTTON_CLASS (parent_class)->toggled (toggle_tool_button);

  context   = pika_toolbox_get_context (tool_button->priv->toolbox);
  tool_info = pika_tool_button_get_tool_info (tool_button);

  if (tool_info)
    {
      PikaDisplay *display;

      if (gtk_toggle_tool_button_get_active (toggle_tool_button))
        pika_context_set_tool (context, tool_info);
      else if (tool_info == pika_context_get_tool (context))
        gtk_toggle_tool_button_set_active (toggle_tool_button, TRUE);

      /* Give focus to the main image. */
      if ((display = pika_context_get_display (context)) &&
          pika_context_get_image (context))
        {
          pika_display_grab_focus (display);
        }
    }
  else
    {
      gtk_toggle_tool_button_set_active (toggle_tool_button, FALSE);
    }
}

static gboolean
pika_tool_button_button_press (GtkWidget      *widget,
                               GdkEventButton *event,
                               PikaToolButton *tool_button)
{
  if (PIKA_IS_TOOL_GROUP (tool_button->priv->tool_item))
    {
      if (gdk_event_triggers_context_menu ((GdkEvent *) event) &&
          pika_tool_button_show_menu (tool_button, (GdkEvent *) event))
        {
          return TRUE;
        }
      else if (event->type == GDK_BUTTON_PRESS && event->button == 1 &&
               ! tool_button->priv->menu_timeout_id)
        {
          GdkEventButton *timeout_event;

          timeout_event        = (GdkEventButton *) gdk_event_copy (
            (GdkEvent *) event);
          timeout_event->time += MENU_TIMEOUT;

          tool_button->priv->menu_timeout_event = (GdkEvent *) timeout_event;

          tool_button->priv->menu_timeout_id = g_timeout_add (
            MENU_TIMEOUT,
            (GSourceFunc) pika_tool_button_menu_timeout,
            tool_button);
        }
    }

  if (event->type == GDK_2BUTTON_PRESS && event->button == 1)
    {
      PikaContext *context;
      PikaDock    *dock;

      context = pika_toolbox_get_context (tool_button->priv->toolbox);
      dock    = PIKA_DOCK (tool_button->priv->toolbox);

      pika_window_strategy_show_dockable_dialog (
        PIKA_WINDOW_STRATEGY (pika_get_window_strategy (context->pika)),
        context->pika,
        pika_dock_get_dialog_factory (dock),
        pika_widget_get_monitor (widget),
        "pika-tool-options");

      return TRUE;
    }

  return FALSE;
}

static gboolean
pika_tool_button_button_release (GtkWidget      *widget,
                                 GdkEventButton *event,
                                 PikaToolButton *tool_button)
{
  if (event->button == 1 && tool_button->priv->menu_timeout_id)
    {
      g_source_remove (tool_button->priv->menu_timeout_id);

      tool_button->priv->menu_timeout_id = 0;

      g_clear_pointer (&tool_button->priv->menu_timeout_event, gdk_event_free);
    }

  return FALSE;
}

static gboolean
pika_tool_button_scroll (GtkWidget      *widget,
                         GdkEventScroll *event,
                         PikaToolButton *tool_button)
{
  PikaToolInfo *tool_info;
  gint          delta;

  tool_info = pika_tool_button_get_tool_info (tool_button);

  switch (event->direction)
    {
    case GDK_SCROLL_UP:
      delta = -1;
      break;

    case GDK_SCROLL_DOWN:
      delta = +1;
      break;

    default:
      return FALSE;
    }

  if (tool_info && PIKA_IS_TOOL_GROUP (tool_button->priv->tool_item))
    {
      PikaContainer *children;
      gint           n_children;
      gint           index;
      gint           i;

      children = pika_viewable_get_children (
        PIKA_VIEWABLE (tool_button->priv->tool_item));

      n_children = pika_container_get_n_children (children);

      index = pika_container_get_child_index (children,
                                              PIKA_OBJECT (tool_info));

      for (i = 1; i < n_children; i++)
        {
          PikaToolInfo *new_tool_info;
          gint          new_index;

          new_index = (index + i * delta) % n_children;
          if (new_index < 0) new_index += n_children;

          new_tool_info = PIKA_TOOL_INFO (
            pika_container_get_child_by_index (children, new_index));

          if (pika_tool_item_get_visible (PIKA_TOOL_ITEM (new_tool_info)))
            {
              pika_tool_group_set_active_tool_info (
                PIKA_TOOL_GROUP (tool_button->priv->tool_item), new_tool_info);

              break;
            }
        }
    }

  return FALSE;
}

static void
pika_tool_button_tool_changed (PikaContext    *context,
                               PikaToolInfo   *tool_info,
                               PikaToolButton *tool_button)
{
  pika_tool_button_update_toggled (tool_button);
}

static void
pika_tool_button_active_tool_changed (PikaToolGroup  *tool_group,
                                      PikaToolButton *tool_button)
{
  pika_tool_button_update (tool_button);
}

static void
pika_tool_button_tool_add (PikaContainer  *container,
                           PikaToolInfo   *tool_info,
                           PikaToolButton *tool_button)
{
  gint index;

  index = pika_container_get_child_index (container, PIKA_OBJECT (tool_info));

  pika_tool_button_add_menu_item (tool_button, tool_info, index);

  pika_tool_button_update (tool_button);
}

static void
pika_tool_button_tool_remove (PikaContainer  *container,
                              PikaToolInfo   *tool_info,
                              PikaToolButton *tool_button)
{
  pika_tool_button_remove_menu_item (tool_button, tool_info);

  pika_tool_button_update (tool_button);
}

static void
pika_tool_button_tool_reorder (PikaContainer  *container,
                               PikaToolInfo   *tool_info,
                               gint            new_index,
                               PikaToolButton *tool_button)
{
  pika_tool_button_remove_menu_item (tool_button, tool_info);
  pika_tool_button_add_menu_item    (tool_button, tool_info, new_index);

  pika_tool_button_update (tool_button);
}

static void
pika_tool_button_icon_size_notify (GtkToolPalette   *palette,
                                   const GParamSpec *pspec,
                                   PikaToolButton   *tool_button)
{
  pika_tool_button_reconstruct_menu (tool_button);

  pika_tool_button_update (tool_button);
}

static void
pika_tool_button_menu_item_activate (GtkMenuItem *menu_item,
                                     PikaAction  *action)
{
  pika_action_activate (action);
}

static gboolean
pika_tool_button_menu_leave_notify (GtkMenu          *menu,
                                    GdkEventCrossing *event,
                                    PikaToolButton   *tool_button)
{
  if (event->mode == GDK_CROSSING_NORMAL &&
      gtk_widget_get_visible (tool_button->priv->menu))
    {
      pika_tool_button_update_menu (tool_button);
    }

  return FALSE;
}

static gboolean
pika_tool_button_menu_timeout (PikaToolButton *tool_button)
{
  GdkEvent *event = tool_button->priv->menu_timeout_event;

  tool_button->priv->menu_timeout_id    = 0;
  tool_button->priv->menu_timeout_event = NULL;

  pika_tool_button_show_menu (tool_button, event);

  gdk_event_free (event);

  /* work around gtk not properly redrawing the button in the toggled state */
  if (gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (tool_button)))
    {
      gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (tool_button),
                                         FALSE);
    }

  return G_SOURCE_REMOVE;
}

static void
pika_tool_button_update (PikaToolButton *tool_button)
{
  PikaToolInfo *tool_info;

  tool_info = pika_tool_button_get_tool_info (tool_button);

  gtk_tool_button_set_icon_name (
    GTK_TOOL_BUTTON (tool_button),
    tool_info ? pika_viewable_get_icon_name (PIKA_VIEWABLE (tool_info)) :
                NULL);

  g_clear_object (&tool_button->priv->tooltip_widget);

  if (tool_info)
    {
      pika_help_set_help_data (GTK_WIDGET (tool_button),
                               tool_info->tooltip, tool_info->help_id);
    }
  else
    {
      pika_help_set_help_data (GTK_WIDGET (tool_button), NULL, NULL);
    }

  if (tool_info)
    {
      const gchar *tool_name = pika_object_get_name (tool_info);
      gchar       *identifier;

      if (g_str_has_prefix (tool_name, "pika-") &&
          g_str_has_suffix (tool_name, "-tool"))
        {
          /* The PikaToolInfo names are of the form "pika-pencil-tool",
           * and action names are of the form "tools-pencil".
           * To simplify things, I make the tool button identifiers the
           * same as the actions, which make them easier to find.
           */
          gchar *suffix;

          identifier = g_strdup_printf ("tools-%s", tool_name + 5);
          suffix = g_strrstr (identifier, "-tool");
          suffix[0] = '\0';
        }
      else
        {
          identifier = g_strdup (tool_name);
        }

      pika_widget_set_identifier (GTK_WIDGET (tool_button), identifier);
      g_free (identifier);
    }

  pika_tool_button_update_toggled (tool_button);
  pika_tool_button_update_menu    (tool_button);
}

static void
pika_tool_button_update_toggled (PikaToolButton *tool_button)
{
  PikaContext  *context;
  PikaToolInfo *tool_info;

  context = pika_toolbox_get_context (tool_button->priv->toolbox);

  tool_info = pika_tool_button_get_tool_info (tool_button);

  gtk_toggle_tool_button_set_active (
    GTK_TOGGLE_TOOL_BUTTON (tool_button),
    tool_info && tool_info == pika_context_get_tool (context));
}

static void
pika_tool_button_update_menu (PikaToolButton *tool_button)
{
  if (tool_button->priv->menu &&
      gtk_widget_get_visible (tool_button->priv->menu))
    {
      PikaToolInfo *tool_info = pika_tool_button_get_tool_info (tool_button);

      if (tool_info)
        {
          gtk_menu_shell_select_item (
            GTK_MENU_SHELL (tool_button->priv->menu),
            g_hash_table_lookup (tool_button->priv->menu_items, tool_info));
        }
    }
}

static void
pika_tool_button_add_menu_item (PikaToolButton *tool_button,
                                PikaToolInfo   *tool_info,
                                gint            index)
{
  PikaAction  *action;
  GtkWidget   *item;
  GtkWidget   *hbox;
  GtkWidget   *image;
  GtkWidget   *label;
  GtkIconSize  icon_size = GTK_ICON_SIZE_MENU;

  action = pika_tool_button_get_action (tool_button, tool_info);

  if (tool_button->priv->palette)
    {
      icon_size = gtk_tool_palette_get_icon_size (
        GTK_TOOL_PALETTE (tool_button->priv->palette));
    }

  item = gtk_menu_item_new ();
  gtk_menu_shell_insert (GTK_MENU_SHELL (tool_button->priv->menu), item, index);
  g_signal_connect (item, "activate",
                    G_CALLBACK (pika_tool_button_menu_item_activate),
                    action);
  pika_help_set_help_data (item, tool_info->tooltip, tool_info->help_id);

  g_object_bind_property (tool_info, "visible",
                          item,      "visible",
                          G_BINDING_SYNC_CREATE);

  g_object_set_data (G_OBJECT (item), "pika-tool-info", tool_info);

  pika_gtk_container_clear (GTK_CONTAINER (item));

  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
  gtk_container_add (GTK_CONTAINER (item), hbox);
  gtk_widget_show (hbox);

  image = gtk_image_new_from_icon_name (
    pika_viewable_get_icon_name (PIKA_VIEWABLE (tool_info)),
    icon_size);
  gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
  gtk_widget_show (image);

  label = gtk_accel_label_new (tool_info->label);
  gtk_label_set_xalign (GTK_LABEL (label), 0.0);
  gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
  gtk_widget_show (label);

  if (action)
    {
      label = pika_accel_label_new (action);
      gtk_label_set_xalign (GTK_LABEL (label), 1.0);
      gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
      gtk_widget_show (label);

      /* TODO: while porting to GAction, this part seems useless, as the toolbox
       * is perfectly working. But maybe I'm missing something. So leaving this
       * here for further investigation.
       * We probably want to check what pika_ui_manager_connect_proxy() does
       * exactly.
       */
#if 0
      if (ui_manager)
        {
          g_signal_emit_by_name (ui_manager, "connect-proxy",
                                 action, item);
        }
#endif
    }

  g_hash_table_insert (tool_button->priv->menu_items, tool_info, item);
}

static void
pika_tool_button_remove_menu_item (PikaToolButton *tool_button,
                                   PikaToolInfo   *tool_info)
{
  GtkWidget *item;

  item = g_hash_table_lookup (tool_button->priv->menu_items, tool_info);

  gtk_container_remove (GTK_CONTAINER (tool_button->priv->menu), item);

  g_hash_table_remove (tool_button->priv->menu_items, tool_info);
}

static void
pika_tool_button_reconstruct_menu_add_menu_item (PikaToolInfo   *tool_info,
                                                 PikaToolButton *tool_button)
{
  pika_tool_button_add_menu_item (tool_button, tool_info, -1);
}

static void
pika_tool_button_reconstruct_menu (PikaToolButton *tool_button)
{
  pika_tool_button_destroy_menu (tool_button);

  if (PIKA_IS_TOOL_GROUP (tool_button->priv->tool_item))
    {
      PikaContainer *children;

      children = pika_viewable_get_children (
        PIKA_VIEWABLE (tool_button->priv->tool_item));

      tool_button->priv->menu = gtk_menu_new ();
      gtk_menu_attach_to_widget (GTK_MENU (tool_button->priv->menu),
                                 GTK_WIDGET (tool_button), NULL);

      g_signal_connect (tool_button->priv->menu, "leave-notify-event",
                        G_CALLBACK (pika_tool_button_menu_leave_notify),
                        tool_button);

      tool_button->priv->menu_items = g_hash_table_new (g_direct_hash,
                                                        g_direct_equal);

      pika_container_foreach (
        children,
        (GFunc) pika_tool_button_reconstruct_menu_add_menu_item,
        tool_button);
    }
}

static void
pika_tool_button_destroy_menu (PikaToolButton *tool_button)
{
  if (tool_button->priv->menu)
    {
      gtk_menu_detach (GTK_MENU (tool_button->priv->menu));
      tool_button->priv->menu = NULL;

      g_clear_pointer (&tool_button->priv->menu_items, g_hash_table_unref);

      if (tool_button->priv->menu_timeout_id)
        {
          g_source_remove (tool_button->priv->menu_timeout_id);

          tool_button->priv->menu_timeout_id = 0;

          g_clear_pointer (&tool_button->priv->menu_timeout_event,
                           gdk_event_free);
        }
    }
}

static gboolean
pika_tool_button_show_menu (PikaToolButton *tool_button,
                            const GdkEvent *trigger_event)
{
  if (! tool_button->priv->menu)
    return FALSE;

  gtk_menu_popup_at_widget (
    GTK_MENU (tool_button->priv->menu),
    GTK_WIDGET (tool_button),
    GDK_GRAVITY_NORTH_EAST,
    GDK_GRAVITY_NORTH_WEST,
    trigger_event);

  pika_tool_button_update_menu (tool_button);

  return TRUE;
}

static PikaAction *
pika_tool_button_get_action (PikaToolButton *tool_button,
                             PikaToolInfo   *tool_info)
{
  PikaAction *action = NULL;

  if (tool_info)
    {
      PikaContext *context;
      Pika        *pika;
      gchar       *name;

      context = pika_toolbox_get_context (tool_button->priv->toolbox);
      pika    = context->pika;
      name    = pika_tool_info_get_action_name (tool_info);

      action = PIKA_ACTION (g_action_map_lookup_action (G_ACTION_MAP (pika->app), name));

      g_free (name);
    }

  return action;
}


/*  public functions  */

GtkToolItem *
pika_tool_button_new (PikaToolbox  *toolbox,
                      PikaToolItem *tool_item)
{
  g_return_val_if_fail (PIKA_IS_TOOLBOX (toolbox), NULL);
  g_return_val_if_fail (tool_item == NULL ||
                        PIKA_IS_TOOL_ITEM (tool_item), NULL);

  return g_object_new (PIKA_TYPE_TOOL_BUTTON,
                       "toolbox",   toolbox,
                       "tool-item", tool_item,
                       NULL);
}

PikaToolbox *
pika_tool_button_get_toolbox (PikaToolButton *tool_button)
{
  g_return_val_if_fail (PIKA_IS_TOOL_BUTTON (tool_button), NULL);

  return tool_button->priv->toolbox;
}

void
pika_tool_button_set_tool_item (PikaToolButton *tool_button,
                                PikaToolItem   *tool_item)
{
  g_return_if_fail (PIKA_IS_TOOL_BUTTON (tool_button));
  g_return_if_fail (tool_item == NULL || PIKA_IS_TOOL_ITEM (tool_item));

  if (tool_item != tool_button->priv->tool_item)
    {
      if (PIKA_IS_TOOL_GROUP (tool_button->priv->tool_item))
        {
          PikaContainer *children;

          children = pika_viewable_get_children (
            PIKA_VIEWABLE (tool_button->priv->tool_item));

          g_signal_handlers_disconnect_by_func (
            tool_button->priv->tool_item,
            pika_tool_button_active_tool_changed,
            tool_button);

          g_signal_handlers_disconnect_by_func (
            children,
            pika_tool_button_tool_add,
            tool_button);
          g_signal_handlers_disconnect_by_func (
            children,
            pika_tool_button_tool_remove,
            tool_button);
          g_signal_handlers_disconnect_by_func (
            children,
            pika_tool_button_tool_reorder,
            tool_button);

          pika_tool_button_destroy_menu (tool_button);
        }

      g_set_object (&tool_button->priv->tool_item, tool_item);

      if (PIKA_IS_TOOL_GROUP (tool_button->priv->tool_item))
        {
          PikaContainer *children;

          children = pika_viewable_get_children (
            PIKA_VIEWABLE (tool_button->priv->tool_item));

          g_signal_connect (
            tool_button->priv->tool_item, "active-tool-changed",
            G_CALLBACK (pika_tool_button_active_tool_changed),
            tool_button);

          g_signal_connect (
            children, "add",
            G_CALLBACK (pika_tool_button_tool_add),
            tool_button);
          g_signal_connect (
            children, "remove",
            G_CALLBACK (pika_tool_button_tool_remove),
            tool_button);
          g_signal_connect (
            children, "reorder",
            G_CALLBACK (pika_tool_button_tool_reorder),
            tool_button);

          pika_tool_button_reconstruct_menu (tool_button);
        }

      pika_tool_button_update (tool_button);

      g_object_notify (G_OBJECT (tool_button), "tool-item");
    }
}

PikaToolItem *
pika_tool_button_get_tool_item (PikaToolButton *tool_button)
{
  g_return_val_if_fail (PIKA_IS_TOOL_BUTTON (tool_button), NULL);

  return tool_button->priv->tool_item;
}

PikaToolInfo *
pika_tool_button_get_tool_info (PikaToolButton *tool_button)
{
  g_return_val_if_fail (PIKA_IS_TOOL_BUTTON (tool_button), NULL);

  if (tool_button->priv->tool_item)
    {
      if (PIKA_IS_TOOL_INFO (tool_button->priv->tool_item))
        {
          return PIKA_TOOL_INFO (tool_button->priv->tool_item);
        }
      else
        {
          return pika_tool_group_get_active_tool_info (
            PIKA_TOOL_GROUP (tool_button->priv->tool_item));
        }
    }

  return NULL;
}