/*
 *   mooui/mooaction.c
 *
 *   Copyright (C) 2004-2005 by Yevgen Muntyan <muntyan@math.tamu.edu>
 *
 *   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.
 *
 *   See COPYING file that comes with this distribution.
 */

#include "mooui/mooaction.h"
#include "mooui/mooactiongroup.h"
#include "mooui/mooaccel.h"
#include "mooutils/moomarshals.h"
#include "mooutils/moocompat.h"
#include <gtk/gtk.h>
#include <string.h>


static void moo_action_class_init       (MooActionClass *klass);

GObject    *moo_action_constructor      (GType                  type,
                                         guint                  n_construct_properties,
                                         GObjectConstructParam *construct_properties);
static void moo_action_init             (MooAction      *action);
static void moo_action_finalize         (GObject        *object);

static void moo_action_set_property     (GObject        *object,
                                         guint           prop_id,
                                         const GValue   *value,
                                         GParamSpec     *pspec);
static void moo_action_get_property     (GObject        *object,
                                         guint           prop_id,
                                         GValue         *value,
                                         GParamSpec     *pspec);

static void moo_action_activate_real    (MooAction      *action);

static void moo_action_set_closure      (MooAction      *action,
                                         MooClosure     *closure);
static void moo_action_set_stock_id     (MooAction      *action,
                                         const char     *stock_id);
static void moo_action_set_label        (MooAction      *action,
                                         const char     *label);
static void moo_action_set_tooltip      (MooAction      *action,
                                         const char     *tooltip);
static void moo_action_set_icon_stock_id(MooAction      *action,
                                         const char     *stock_id);
static void moo_action_set_icon         (MooAction      *action,
                                         GdkPixbuf      *icon);

static void moo_action_set_sensitive_real (MooAction      *action,
                                         gboolean        sensitive);
static void moo_action_set_visible_real (MooAction      *action,
                                         gboolean        visible);

static GtkWidget *moo_action_create_menu_item_real (MooAction      *action,
                                                    GtkMenuShell   *menushell,
                                                    int             position);
static gboolean   moo_action_create_tool_item_real (MooAction      *action,
                                                    GtkToolbar     *toolbar,
                                                    int             position);

static void moo_action_add_proxy        (MooAction      *action,
                                         GtkWidget      *proxy);

#if GTK_MINOR_VERSION < 4
static void tool_item_callback (G_GNUC_UNUSED GtkWidget *widget,
                                MooAction *action)
{
    moo_action_activate (action);
}
#endif /* GTK_MINOR_VERSION < 4 */


enum {
    PROP_0,

    PROP_ID,
    PROP_GROUP_ID,

    PROP_NAME,

    PROP_CLOSURE,

    PROP_STOCK_ID,
    PROP_LABEL,
    PROP_TOOLTIP,

    PROP_NO_ACCEL,
    PROP_ACCEL,
    PROP_DEFAULT_ACCEL,

    PROP_ICON,
    PROP_ICON_STOCK_ID,

    PROP_DEAD,
    PROP_SENSITIVE,
    PROP_VISIBLE
};

enum {
    ACTIVATE,
    SET_SENSITIVE,
    SET_VISIBLE,
    LAST_SIGNAL
};


static guint signals[LAST_SIGNAL] = {0};


/* MOO_TYPE_ACTION */
G_DEFINE_TYPE (MooAction, moo_action, G_TYPE_OBJECT)


static void moo_action_class_init (MooActionClass *klass)
{
    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

    gobject_class->constructor = moo_action_constructor;
    gobject_class->finalize = moo_action_finalize;
    gobject_class->set_property = moo_action_set_property;
    gobject_class->get_property = moo_action_get_property;

    klass->activate = moo_action_activate_real;
    klass->add_proxy = moo_action_add_proxy;
    klass->set_sensitive = moo_action_set_sensitive_real;
    klass->set_visible = moo_action_set_visible_real;
    klass->create_menu_item = moo_action_create_menu_item_real;
    klass->create_tool_item = moo_action_create_tool_item_real;

    g_object_class_install_property (gobject_class,
                                     PROP_ID,
                                     g_param_spec_string ("id",
                                                          "id",
                                                          "id",
                                                          NULL,
                                                          G_PARAM_READWRITE |
                                                                  G_PARAM_CONSTRUCT_ONLY));

    g_object_class_install_property (gobject_class,
                                     PROP_GROUP_ID,
                                     g_param_spec_string ("group-id",
                                                          "group-id",
                                                          "group-id",
                                                          NULL,
                                                          G_PARAM_READWRITE |
                                                                  G_PARAM_CONSTRUCT_ONLY));

    g_object_class_install_property (gobject_class,
                                     PROP_NAME,
                                     g_param_spec_string ("name",
                                                          "name",
                                                          "name",
                                                          NULL,
                                                          G_PARAM_READWRITE |
                                                                  G_PARAM_CONSTRUCT));

    g_object_class_install_property (gobject_class,
                                     PROP_CLOSURE,
                                     g_param_spec_object ("closure",
                                                          "closure",
                                                          "closure",
                                                          MOO_TYPE_CLOSURE,
                                                          G_PARAM_READWRITE |
                                                                  G_PARAM_CONSTRUCT));

    g_object_class_install_property (gobject_class,
                                     PROP_STOCK_ID,
                                     g_param_spec_string ("stock-id",
                                                          "stock-id",
                                                          "stock-id",
                                                          NULL,
                                                          G_PARAM_READWRITE |
                                                                  G_PARAM_CONSTRUCT));

    g_object_class_install_property (gobject_class,
                                     PROP_LABEL,
                                     g_param_spec_string ("label",
                                                          "label",
                                                          "label",
                                                          NULL,
                                                          G_PARAM_READWRITE |
                                                                  G_PARAM_CONSTRUCT));

    g_object_class_install_property (gobject_class,
                                     PROP_TOOLTIP,
                                     g_param_spec_string ("tooltip",
                                                          "tooltip",
                                                          "tooltip",
                                                          NULL,
                                                          G_PARAM_READWRITE |
                                                                  G_PARAM_CONSTRUCT));

    g_object_class_install_property (gobject_class,
                                     PROP_NO_ACCEL,
                                     g_param_spec_boolean ("no-accel",
                                                           "no-accel",
                                                           "no-accel",
                                                           FALSE,
                                                           G_PARAM_READWRITE |
                                                                   G_PARAM_CONSTRUCT));

    g_object_class_install_property (gobject_class,
                                     PROP_ACCEL,
                                     g_param_spec_string ("accel",
                                                          "accel",
                                                          "accel",
                                                          NULL,
                                                          G_PARAM_READWRITE |
                                                                  G_PARAM_CONSTRUCT));

    g_object_class_install_property (gobject_class,
                                     PROP_DEFAULT_ACCEL,
                                     g_param_spec_string ("default-accel",
                                                          "default-accel",
                                                          "default-accel",
                                                          NULL,
                                                          G_PARAM_READWRITE |
                                                                  G_PARAM_CONSTRUCT));

    g_object_class_install_property (gobject_class,
                                     PROP_SENSITIVE,
                                     g_param_spec_boolean ("sensitive",
                                                           "sensitive",
                                                           "sensitive",
                                                           TRUE,
                                                           G_PARAM_READWRITE |
                                                                   G_PARAM_CONSTRUCT));

    g_object_class_install_property (gobject_class,
                                     PROP_VISIBLE,
                                     g_param_spec_boolean ("visible",
                                                           "visible",
                                                           "visible",
                                                           TRUE,
                                                           G_PARAM_READWRITE |
                                                                   G_PARAM_CONSTRUCT));

    g_object_class_install_property (gobject_class,
                                     PROP_DEAD,
                                     g_param_spec_boolean ("dead",
                                                           "dead",
                                                           "dead",
                                                           FALSE,
                                                           G_PARAM_READWRITE |
                                                                   G_PARAM_CONSTRUCT_ONLY));

    g_object_class_install_property (gobject_class,
                                     PROP_ICON_STOCK_ID,
                                     g_param_spec_string ("icon-stock-id",
                                                          "icon-stock-id",
                                                          "icon-stock-id",
                                                          NULL,
                                                          G_PARAM_READWRITE |
                                                                  G_PARAM_CONSTRUCT));

    g_object_class_install_property (gobject_class,
                                     PROP_ICON,
                                     g_param_spec_object ("icon",
                                                          "icon",
                                                          "icon",
                                                          GDK_TYPE_PIXBUF,
                                                          G_PARAM_READWRITE |
                                                                  G_PARAM_CONSTRUCT));

    signals[ACTIVATE] =
        g_signal_new ("activate",
                      G_OBJECT_CLASS_TYPE (klass),
                      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
                      G_STRUCT_OFFSET (MooActionClass, activate),
                      NULL, NULL,
                      _moo_marshal_VOID__VOID,
                      G_TYPE_NONE, 0);

    signals[SET_SENSITIVE] =
        g_signal_new ("set-sensitive",
                      G_OBJECT_CLASS_TYPE (klass),
                      G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
                      G_STRUCT_OFFSET (MooActionClass, set_sensitive),
                      NULL, NULL,
                      _moo_marshal_VOID__BOOL,
                      G_TYPE_NONE, 1,
                      G_TYPE_BOOLEAN);

    signals[SET_VISIBLE] =
        g_signal_new ("set-visible",
                      G_OBJECT_CLASS_TYPE (klass),
                      G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
                      G_STRUCT_OFFSET (MooActionClass, set_visible),
                      NULL, NULL,
                      _moo_marshal_VOID__BOOL,
                      G_TYPE_NONE, 1,
                      G_TYPE_BOOLEAN);
}


static void moo_action_init (MooAction *action)
{
    action->constructed = FALSE;

    action->group = NULL;

    action->id = NULL;
    action->group_id = NULL;
    action->name = NULL;

    action->no_accel = FALSE;
    action->accel = NULL;
    action->default_accel = NULL;
    action->dead = FALSE;
    action->visible = TRUE;
    action->sensitive = TRUE;
    action->closure = NULL;
    action->stock_id = NULL;
    action->label = NULL;
    action->tooltip = NULL;
    action->icon_stock_id = NULL;
    action->icon = NULL;
}


GObject    *moo_action_constructor      (GType                  type,
                                         guint                  n_props,
                                         GObjectConstructParam *props)
{
    GObject *object;
    MooAction *action;

    object =
        G_OBJECT_CLASS(moo_action_parent_class)->constructor (type, n_props, props);

    action = MOO_ACTION (object);
    action->constructed = TRUE;

    if (action->dead)
    {
        action->visible = FALSE;
        action->sensitive = FALSE;
        action->no_accel = TRUE;
        g_free (action->accel);
        action->accel = g_strdup ("");
        g_free (action->default_accel);
        action->default_accel = g_strdup ("");
        g_free (action->stock_id);
        action->stock_id = NULL;
        g_free (action->icon_stock_id);
        action->icon_stock_id = NULL;
        g_free (action->label);
        action->label = g_strdup ("");
        g_free (action->tooltip);
        action->tooltip = g_strdup ("");
        if (action->icon) g_object_unref (action->icon);
        action->icon = NULL;
        return object;
    }

    if (!action->id || !action->id[0])
    {
        g_critical ("%s: no action id", G_STRLOC);
        if (!action->id)
            action->id = g_strdup ("");
        action->no_accel = TRUE;
    }

    if (!action->name)
        action->name = g_strdup (action->id);

    if (!action->group_id)
    {
        g_critical ("action doesn't have group id");
        if (!action->group_id)
            action->group_id = g_strdup ("");
    }

    if (!action->accel)
        action->accel = g_strdup ("");
    if (!action->default_accel)
        action->default_accel = g_strdup (action->accel);

    moo_action_set_default_accel (action, action->default_accel);
    moo_action_set_accel (action, action->accel);

    return object;
}


static void moo_action_finalize       (GObject      *object)
{
    MooAction *action = MOO_ACTION (object);

    if (action->closure)
        g_object_unref (action->closure);
    g_free (action->id);
    g_free (action->group_id);
    g_free (action->name);
    g_free (action->stock_id);
    g_free (action->label);
    g_free (action->tooltip);
    g_free (action->icon_stock_id);
    if (action->icon)
        g_object_unref (action->icon);

    G_OBJECT_CLASS (moo_action_parent_class)->finalize (object);
}


static void moo_action_activate_real    (MooAction      *action)
{
    g_return_if_fail (MOO_IS_ACTION (action));
    if (action->closure)
        moo_closure_invoke (action->closure);
}


static void moo_action_get_property     (GObject        *object,
                                         guint           prop_id,
                                         GValue         *value,
                                         GParamSpec     *pspec)
{
    MooAction *action = MOO_ACTION (object);

    switch (prop_id)
    {
        case PROP_ID:
            g_value_set_string (value, action->id);
            break;
        case PROP_GROUP_ID:
            g_value_set_string (value, action->group_id);
            break;
        case PROP_NAME:
            g_value_set_string (value, action->name);
            break;
        case PROP_SENSITIVE:
            g_value_set_boolean (value, action->sensitive);
            break;
        case PROP_VISIBLE:
            g_value_set_boolean (value, action->visible);
            break;
        case PROP_DEAD:
            g_value_set_boolean (value, action->dead);
            break;
        case PROP_CLOSURE:
            g_value_set_object (value, action->closure);
            break;
        case PROP_STOCK_ID:
            g_value_set_string (value, action->stock_id);
            break;
        case PROP_LABEL:
            g_value_set_string (value, action->label);
            break;
        case PROP_TOOLTIP:
            g_value_set_string (value, action->tooltip);
            break;
        case PROP_NO_ACCEL:
            g_value_set_boolean (value, action->no_accel);
            break;
        case PROP_ACCEL:
            g_value_set_string (value, moo_action_get_accel (action));
            break;
        case PROP_DEFAULT_ACCEL:
            g_value_set_string (value, moo_action_get_default_accel (action));
            break;
        case PROP_ICON_STOCK_ID:
            g_value_set_string (value, action->icon_stock_id);
            break;
        case PROP_ICON:
            g_value_set_object (value, action->icon);
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}


static void moo_action_set_property     (GObject        *object,
                                         guint           prop_id,
                                         const GValue   *value,
                                         GParamSpec     *pspec)
{
    MooAction *action = MOO_ACTION (object);

    switch (prop_id)
    {
        case PROP_ID:
            g_return_if_fail (action->id == NULL);
            action->id = g_strdup (g_value_get_string (value));
            break;
        case PROP_GROUP_ID:
            g_return_if_fail (action->group_id == NULL);
            action->group_id = g_strdup (g_value_get_string (value));
            break;
        case PROP_NAME:
            g_free (action->name);
            action->name = g_strdup (g_value_get_string (value));
            break;
        case PROP_SENSITIVE:
            moo_action_set_sensitive (action, g_value_get_boolean (value));
            break;
        case PROP_VISIBLE:
            moo_action_set_visible (action, g_value_get_boolean (value));
            break;
        case PROP_DEAD:
            action->dead = g_value_get_boolean (value);
            break;
        case PROP_CLOSURE:
            moo_action_set_closure (action,
                                    MOO_CLOSURE (g_value_get_object (value)));
            break;
        case PROP_STOCK_ID:
            moo_action_set_stock_id (action,
                                     g_value_get_string (value));
            break;
        case PROP_LABEL:
            moo_action_set_label (action,
                                  g_value_get_string (value));
            break;
        case PROP_TOOLTIP:
            moo_action_set_tooltip (action,
                                    g_value_get_string (value));
            break;
        case PROP_NO_ACCEL:
            action->no_accel = g_value_get_boolean (value);
            break;
        case PROP_ACCEL:
            moo_action_set_accel (action,
                                  g_value_get_string (value));
            break;
        case PROP_DEFAULT_ACCEL:
            moo_action_set_default_accel (action,
                                          g_value_get_string (value));
            break;
        case PROP_ICON_STOCK_ID:
            moo_action_set_icon_stock_id (action,
                                          g_value_get_string (value));
            break;
        case PROP_ICON:
            moo_action_set_icon (action, GDK_PIXBUF (g_value_get_object (value)));
            break;

        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}


static void moo_action_set_closure      (MooAction      *action,
                                         MooClosure     *closure)
{
    if (action->closure == closure) return;
    if (action->closure) g_object_unref (G_OBJECT (action->closure));
    action->closure = closure;
    if (action->closure) {
        g_object_ref (G_OBJECT (action->closure));
        gtk_object_sink (GTK_OBJECT (action->closure));
    }
}


static void moo_action_set_stock_id     (MooAction      *action,
                                         const char     *stock_id)
{
    if (!stock_id && !action->stock_id) return;
    if (stock_id && action->stock_id && !strcmp (stock_id, action->stock_id)) return;

    if (action->stock_id) {
        g_free (action->stock_id);
        action->stock_id = NULL;
    }

    if (stock_id) {
        GtkStockItem item;
        char *accel = NULL;

        g_return_if_fail (gtk_stock_lookup (stock_id, &item));
        g_free (action->stock_id);
        action->stock_id = g_strdup (stock_id);
        if (item.keyval || item.modifier) {
            accel = gtk_accelerator_name (item.keyval, item.modifier);
            moo_action_set_accel (action, accel);
            g_free (accel);
        }
        else
            moo_action_set_accel (action, "");
    }
    else {
        moo_action_set_accel (action, "");
    }
    g_object_notify (G_OBJECT (action), "stock_id");
}


static void moo_action_set_label        (MooAction      *action,
                                         const char     *label)
{
    g_free (action->label);
    action->label = g_strdup (label);
}


static void moo_action_set_tooltip      (MooAction      *action,
                                         const char     *tooltip)
{
    g_free (action->tooltip);
    action->tooltip = g_strdup (tooltip);
}


void moo_action_set_accel               (MooAction      *action,
                                         const char     *accel)
{
    g_return_if_fail (MOO_IS_ACTION (action));

    if (!action->constructed) {
        g_free (action->accel);
        action->accel = g_strdup (accel);
        return;
    }

    g_return_if_fail (accel != NULL);

    moo_set_accel (moo_action_get_accel_path (action), accel);
}


void moo_action_set_default_accel       (MooAction      *action,
                                         const char     *accel)
{
    g_return_if_fail (MOO_IS_ACTION (action));

    if (!action->constructed) {
        g_free (action->default_accel);
        action->default_accel = g_strdup (accel);
        return;
    }

    g_return_if_fail (accel != NULL);

    moo_set_default_accel (moo_action_get_accel_path (action), accel);
}


const char  *moo_action_get_accel           (MooAction      *action)
{
    g_return_val_if_fail (MOO_IS_ACTION (action), NULL);
    return moo_get_accel (moo_action_get_accel_path (action));
}

const char  *moo_action_get_default_accel   (MooAction      *action)
{
    g_return_val_if_fail (MOO_IS_ACTION (action), NULL);
    return moo_get_default_accel (moo_action_get_accel_path (action));
}

char        *moo_action_get_accel_label     (MooAction      *action)
{
    g_return_val_if_fail (MOO_IS_ACTION (action), NULL);
    return moo_get_accel_label (moo_action_get_accel (action));
}

char        *moo_action_get_default_accel_label (MooAction      *action)
{
    g_return_val_if_fail (MOO_IS_ACTION (action), NULL);
    return moo_get_accel_label (moo_action_get_default_accel (action));
}


void         moo_action_set_no_accel        (MooAction      *action,
                                             gboolean        no_accel)
{
    g_return_if_fail (MOO_IS_ACTION (action));

    action->no_accel = no_accel;

    if (no_accel)
        moo_action_set_accel (action, "");
}

gboolean     moo_action_get_no_accel        (MooAction      *action)
{
    g_return_val_if_fail (MOO_IS_ACTION (action), TRUE);
    return action->no_accel;
}


GtkWidget   *moo_action_create_menu_item    (MooAction      *action,
                                             GtkMenuShell   *menushell,
                                             int             position)
{
    MooActionClass *klass;

    g_return_val_if_fail (MOO_IS_ACTION (action), NULL);
    g_return_val_if_fail (!action->dead, NULL);

    klass = MOO_ACTION_GET_CLASS (action);
    g_return_val_if_fail (klass != NULL && klass->create_menu_item != NULL, NULL);
    return klass->create_menu_item (action, menushell, position);
}


gboolean     moo_action_create_tool_item    (MooAction      *action,
                                             GtkToolbar     *toolbar,
                                             int             position)
{
    MooActionClass *klass;

    g_return_val_if_fail (MOO_IS_ACTION (action), FALSE);
    g_return_val_if_fail (!action->dead, FALSE);

    klass = MOO_ACTION_GET_CLASS (action);
    g_return_val_if_fail (klass != NULL && klass->create_tool_item != NULL, FALSE);
    return klass->create_tool_item (action, toolbar, position);
}


const char  *moo_action_get_id        (MooAction      *action)
{
    g_return_val_if_fail (MOO_IS_ACTION (action), NULL);
    return action->id;
}

const char  *moo_action_get_group_id        (MooAction      *action)
{
    g_return_val_if_fail (MOO_IS_ACTION (action), NULL);
    return action->group_id;
}

const char  *moo_action_get_name            (MooAction      *action)
{
    g_return_val_if_fail (MOO_IS_ACTION (action), NULL);
    return action->name;
}


const char  *moo_action_get_accel_path  (MooAction      *action)
{
    g_return_val_if_fail (MOO_IS_ACTION (action), NULL);
    return moo_action_make_accel_path (action->group_id, action->id);
}


const char  *moo_action_make_accel_path (const char     *group_id,
                                         const char     *action_id)
{
    static char *result = NULL;
    g_free (result);
    result = NULL;

    g_return_val_if_fail (action_id != NULL && action_id[0] != 0, NULL);

    if (group_id && group_id[0])
        result = g_strdup_printf ("<MooAction>/%s/%s", group_id, action_id);
    else
        result = g_strdup_printf ("<MooAction>/%s", action_id);

    g_assert (result != NULL);
    return result;
}


static GtkWidget *moo_action_create_menu_item_real (MooAction      *action,
                                                    GtkMenuShell   *menu_shell,
                                                    int             position)
{
    GtkWidget *item = NULL;

    if (action->stock_id)
        item = gtk_image_menu_item_new_from_stock (action->stock_id,
                                                   NULL);
    else
    {
        GtkWidget *icon = NULL;
        if (action->icon_stock_id)
        {
            icon = gtk_image_new_from_stock (action->icon_stock_id, GTK_ICON_SIZE_MENU);
            if (!icon) g_warning ("could not create stock icon '%s'",
                                action->icon_stock_id);
            else gtk_widget_show (icon);
        }
        item = gtk_image_menu_item_new_with_mnemonic (action->label);
        if (icon) gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), icon);
    }

    if (!action->no_accel)
        gtk_menu_item_set_accel_path (GTK_MENU_ITEM (item),
                                      moo_action_get_accel_path (action));

    moo_action_add_proxy (action, item);

    if (position >= 0)
        gtk_menu_shell_insert (menu_shell, item, position);
    else
        gtk_menu_shell_append (menu_shell, item);

    return item;
}


static gboolean moo_action_create_tool_item_real (MooAction      *action,
                                                  GtkToolbar     *toolbar,
                                                  int             position)
{
#if GTK_MINOR_VERSION >= 4
    GtkToolItem *item = NULL;
    GtkTooltips *tooltips = NULL;

    if (action->stock_id)
    {
        item = gtk_tool_button_new_from_stock (action->stock_id);
    }
    else
    {
        GtkWidget *icon = NULL;
        if (action->icon_stock_id)
        {
            icon = gtk_image_new_from_stock (action->icon_stock_id,
                                             gtk_toolbar_get_icon_size (toolbar));
            if (!icon) g_warning ("could not create stock icon '%s'",
                                  action->icon_stock_id);
            else gtk_widget_show (icon);
        }
        item = gtk_tool_button_new (icon, action->label);
        gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE);
    }

    if (action->group)
        tooltips = moo_action_group_get_tooltips (MOO_ACTION_GROUP (action->group));
    if (tooltips && action->tooltip)
        gtk_tool_item_set_tooltip (item,
                                   tooltips,
                                   action->tooltip,
                                   action->tooltip);

    gtk_toolbar_insert (toolbar, item, position);
    gtk_container_child_set (GTK_CONTAINER (toolbar), GTK_WIDGET (item),
                             "homogeneous", FALSE, NULL);

#else /*  GTK_MINOR_VERSION < 4 */

    GtkWidget *item = NULL;
    if (action->stock_id)
    {
        item = gtk_toolbar_insert_stock (toolbar,
                                         action->stock_id,
                                         action->tooltip,
                                         action->tooltip,
                                         (GtkSignalFunc)tool_item_callback,
                                         action,
                                         position);
    }
    else
    {
        GtkWidget *icon = NULL;
        if (action->icon_stock_id)
        {
            icon = gtk_image_new_from_stock (action->icon_stock_id,
                                             gtk_toolbar_get_icon_size (toolbar));
            if (!icon) g_warning ("could not create stock icon '%s'",
                                  action->icon_stock_id);
            else gtk_widget_show (icon);
        }
        item = gtk_toolbar_insert_item (toolbar,
                                        action->label,
                                        action->tooltip,
                                        action->tooltip,
                                        icon,
                                        NULL,
                                        NULL,
                                        position);
        gtk_button_set_use_underline (GTK_BUTTON (item), TRUE);
    }

#endif /* GTK_MINOR_VERSION < 4 */

    moo_action_add_proxy (action, GTK_WIDGET (item));

    return TRUE;
}


void         moo_action_activate        (MooAction      *action)
{
    g_return_if_fail (MOO_IS_ACTION (action));
    g_signal_emit (action, signals[ACTIVATE], 0);
}


void         moo_action_set_sensitive   (MooAction      *action,
                                         gboolean        sensitive)
{
    g_return_if_fail (MOO_IS_ACTION (action));
    g_signal_emit (action, signals[SET_SENSITIVE], 0, sensitive);
}

void         moo_action_set_visible    (MooAction      *action,
                                        gboolean        visible)
{
    g_return_if_fail (MOO_IS_ACTION (action));
    g_signal_emit (action, signals[SET_VISIBLE], 0, visible);
}


static void         moo_action_set_sensitive_real   (MooAction      *action,
                                                     gboolean        sensitive)
{
    g_return_if_fail (MOO_IS_ACTION (action));
    action->sensitive = sensitive;
    g_object_notify (G_OBJECT (action), "sensitive");
}

static void         moo_action_set_visible_real     (MooAction      *action,
                                                     gboolean        visible)
{
    g_return_if_fail (MOO_IS_ACTION (action));
    action->visible = visible;
    g_object_notify (G_OBJECT (action), "visible");
}


static void moo_action_set_icon_stock_id(MooAction      *action,
                                         const char     *stock_id)
{
    if (action->icon_stock_id == stock_id) return;
    g_free (action->icon_stock_id);
    action->icon_stock_id = g_strdup (stock_id);
    g_object_notify (G_OBJECT (action), "icon-stock-id");
}


static void moo_action_set_icon         (G_GNUC_UNUSED MooAction      *action,
                                         GdkPixbuf      *icon)
{
    if (icon)
        g_warning ("%s: implement me", G_STRLOC);
}


/****************************************************************************/

static void set_visible_callback     (GtkWidget  *proxy,
                                      gboolean    visible);
static void proxy_destroyed          (MooAction  *action,
                                      gpointer    proxy);
static void action_destroyed         (GtkWidget  *proxy,
                                      gpointer    action);

static void set_visible_callback     (GtkWidget  *proxy,
                                      gboolean    visible)
{
    if (visible)
        gtk_widget_show (proxy);
    else
        gtk_widget_hide (proxy);
}

static void proxy_destroyed          (MooAction  *action,
                                      gpointer    proxy)
{
    g_signal_handlers_disconnect_by_func (action, (gpointer)gtk_widget_set_sensitive, proxy);
    g_signal_handlers_disconnect_by_func (action, (gpointer)set_visible_callback, proxy);
    g_object_weak_unref (G_OBJECT (action), (GWeakNotify)action_destroyed, proxy);
}

static void action_destroyed         (GtkWidget  *proxy,
                                      gpointer    action)
{
    g_signal_handlers_disconnect_by_func (proxy, (gpointer)moo_action_activate, action);
    g_object_weak_unref (G_OBJECT (proxy), (GWeakNotify)proxy_destroyed, action);
}


static void moo_action_add_proxy        (MooAction      *action,
                                         GtkWidget      *proxy)
{
    gtk_widget_set_sensitive (proxy, action->sensitive);

    if (action->visible)
        gtk_widget_show (proxy);
    else
        gtk_widget_hide (proxy);

    if (GTK_IS_MENU_ITEM (proxy))
        g_signal_connect_swapped (proxy, "activate",
                                  G_CALLBACK (moo_action_activate),
                                  action);
    else if (
#if GTK_MINOR_VERSION >= 4
        GTK_IS_TOOL_BUTTON (proxy) ||
#endif /* GTK_MINOR_VERSION >= 4 */
        GTK_IS_BUTTON (proxy))
    {
        g_signal_connect_swapped (proxy, "clicked",
                                  G_CALLBACK (moo_action_activate),
                                  action);
    }
    else
    {
        g_critical ("unknown proxy type");
    }

    g_signal_connect_swapped (action, "set-sensitive",
                              G_CALLBACK (gtk_widget_set_sensitive),
                              proxy);
    g_signal_connect_swapped (action, "set-visible",
                              G_CALLBACK (set_visible_callback),
                              proxy);

    g_object_weak_ref (G_OBJECT (proxy),
                       (GWeakNotify)proxy_destroyed,
                       action);
    g_object_weak_ref (G_OBJECT (action),
                       (GWeakNotify)action_destroyed,
                       proxy);
}