/*
 *   mooaction.c
 *
 *   Copyright (C) 2004-2006 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 "mooutils/mooaction.h"
#include "mooutils/mooactiongroup.h"
#include "mooutils/mooaccel.h"
#include "mooutils/moomarshals.h"
#include "mooutils/moocompat.h"
#include "mooutils/mooutils-gobject.h"
#include "mooutils/mooutils-misc.h"
#include <gtk/gtk.h>
#include <string.h>


static void moo_action_class_init       (MooActionClass *klass);

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

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_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);
static GtkWidget *moo_action_create_tool_item_real (MooAction      *action,
                                                    GtkWidget      *toolbar,
                                                    int             position,
                                                    MooToolItemFlags flags);

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_NAME,
    PROP_GROUP_NAME,

    PROP_CLOSURE,
    PROP_CLOSURE_OBJECT,
    PROP_CLOSURE_SIGNAL,
    PROP_CLOSURE_CALLBACK,
    PROP_CLOSURE_PROXY_FUNC,

    PROP_STOCK_ID,
    PROP_LABEL,
    PROP_TOOLTIP,

    PROP_NO_ACCEL,
    PROP_ACCEL,
    PROP_FORCE_ACCEL_LABEL,

    PROP_ICON,
    PROP_ICON_STOCK_ID,

    PROP_DEAD,
    PROP_SENSITIVE,
    PROP_VISIBLE,
    PROP_IS_IMPORTANT
};

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_object_class_install_property (gobject_class,
                                     PROP_GROUP_NAME,
                                     g_param_spec_string ("group-name",
                                             "group-name",
                                             "group-name",
                                             NULL,
                                             G_PARAM_READWRITE));

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

    g_object_class_install_property (gobject_class,
                                     PROP_CLOSURE,
                                     g_param_spec_boxed ("closure",
                                             "closure",
                                             "closure",
                                             MOO_TYPE_CLOSURE,
                                             G_PARAM_READWRITE));

    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_object_class_install_property (gobject_class,
                                     PROP_LABEL,
                                     g_param_spec_string ("label",
                                             "label",
                                             "label",
                                             NULL,
                                             G_PARAM_READWRITE));

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

    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_object_class_install_property (gobject_class,
                                     PROP_FORCE_ACCEL_LABEL,
                                     g_param_spec_boolean ("force-accel-label",
                                             "force-accel-label",
                                             "force-accel-label",
                                             FALSE,
                                             G_PARAM_READWRITE));

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

    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_IS_IMPORTANT,
                                     g_param_spec_boolean ("is-important",
                                             "is-important",
                                             "is-important",
                                             FALSE,
                                             G_PARAM_READWRITE));

    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_object_class_install_property (gobject_class,
                                     PROP_ICON,
                                     g_param_spec_object ("icon",
                                             "icon",
                                             "icon",
                                             GDK_TYPE_PIXBUF,
                                             G_PARAM_READWRITE));

    g_object_class_install_property (gobject_class,
                                     PROP_CLOSURE_OBJECT,
                                     g_param_spec_object ("closure-object",
                                             "closure-object",
                                             "closure-object",
                                             G_TYPE_OBJECT,
                                             G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
    g_object_class_install_property (gobject_class,
                                     PROP_CLOSURE_SIGNAL,
                                     g_param_spec_string ("closure-signal",
                                             "closure-signal",
                                             "closure-signal",
                                             NULL,
                                             G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
    g_object_class_install_property (gobject_class,
                                     PROP_CLOSURE_CALLBACK,
                                     g_param_spec_pointer ("closure-callback",
                                             "closure-callback",
                                             "closure-callback",
                                             G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
    g_object_class_install_property (gobject_class,
                                     PROP_CLOSURE_PROXY_FUNC,
                                     g_param_spec_pointer ("closure-proxy-func",
                                             "closure-proxy-func",
                                             "closure-proxy-func",
                                             G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));

    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->visible = TRUE;
    action->sensitive = TRUE;
}


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

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

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


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

    MooClosure *closure = NULL;
    gpointer closure_object = NULL;
    const char *closure_signal = NULL;
    GCallback closure_callback = NULL;
    GCallback closure_proxy_func = NULL;

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

    if (action->dead)
        return object;

    for (i = 0; i < n_props; ++i)
    {
        const char *name = props[i].pspec->name;
        GValue *value = props[i].value;

        if (!strcmp (name, "closure-callback"))
            closure_callback = g_value_get_pointer (value);
        else if (!strcmp (name, "closure-signal"))
            closure_signal = g_value_get_string (value);
        else if (!strcmp (name, "closure-proxy-func"))
            closure_proxy_func = g_value_get_pointer (value);
        else if (!strcmp (name, "closure-object"))
            closure_object = g_value_get_object (value);
    }

    if (closure_callback || closure_signal)
    {
        if (closure_object)
            closure = moo_closure_new_simple (closure_object, closure_signal,
                                              closure_callback, closure_proxy_func);
        else
            g_warning ("%s: invalid closure params", G_STRLOC);
    }

    if (closure)
        moo_action_set_closure (action, closure);

    return 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_NAME:
            g_value_set_string (value, action->group_name);
            break;
        case PROP_NAME:
            g_value_set_string (value, action->name);
            break;
        case PROP_SENSITIVE:
            g_value_set_boolean (value, action->sensitive != 0);
            break;
        case PROP_VISIBLE:
            g_value_set_boolean (value, action->visible != 0);
            break;
        case PROP_DEAD:
            g_value_set_boolean (value, action->dead != 0);
            break;
        case PROP_CLOSURE:
            g_value_set_boxed (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 != 0);
            break;
        case PROP_FORCE_ACCEL_LABEL:
            g_value_set_boolean (value, action->force_accel_label != 0);
            break;
        case PROP_IS_IMPORTANT:
            g_value_set_boolean (value, action->is_important != 0);
            break;
        case PROP_ACCEL:
            g_value_set_string (value, action->default_accel);
            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_free (action->id);
            action->id = g_strdup (g_value_get_string (value));
            g_object_notify (object, "id");
            break;
        case PROP_GROUP_NAME:
            g_free (action->group_name);
            action->group_name = g_strdup (g_value_get_string (value));
            g_object_notify (object, "group-name");
            break;
        case PROP_NAME:
            g_free (action->name);
            action->name = g_strdup (g_value_get_string (value));
            g_object_notify (object, "name");
            break;
        case PROP_SENSITIVE:
            moo_action_set_sensitive (action,
                                      g_value_get_boolean (value) != 0);
            break;
        case PROP_VISIBLE:
            moo_action_set_visible (action,
                                    g_value_get_boolean (value) != 0);
            break;
        case PROP_DEAD:
            action->dead = g_value_get_boolean (value) != 0;
            g_object_notify (object, "dead");
            break;
        case PROP_IS_IMPORTANT:
            action->is_important = g_value_get_boolean (value) != 0;
            g_object_notify (object, "is_important");
            break;
        case PROP_CLOSURE:
            moo_action_set_closure (action, g_value_get_boxed (value));
            break;
        case PROP_STOCK_ID:
            g_free (action->stock_id);
            action->stock_id = g_strdup (g_value_get_string (value));
            g_object_notify (G_OBJECT (action), "stock_id");
            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) != 0;
            g_object_notify (object, "no-accel");
            break;
        case PROP_FORCE_ACCEL_LABEL:
            action->force_accel_label = g_value_get_boolean (value) != 0;
            g_object_notify (object, "force-accel-label");
            break;
        case PROP_ACCEL:
            g_free (action->default_accel);
            action->default_accel = g_strdup (g_value_get_string (value));
            g_object_notify (object, "accel");
            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;

        case PROP_CLOSURE_OBJECT:
        case PROP_CLOSURE_SIGNAL:
        case PROP_CLOSURE_CALLBACK:
        case PROP_CLOSURE_PROXY_FUNC:
            /* constructor handles these */
            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)
        moo_closure_unref (action->closure);

    action->closure = closure;

    if (action->closure)
    {
        moo_closure_ref (action->closure);
        moo_closure_sink (action->closure);
    }
}


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_no_accel (MooAction      *action,
                         gboolean        no_accel)
{
    g_return_if_fail (MOO_IS_ACTION (action));
    action->no_accel = no_accel ? TRUE : FALSE;
}

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


GtkWidget*
moo_action_create_menu_item (MooAction *action)
{
    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);
}


GtkWidget*
moo_action_create_tool_item (MooAction      *action,
                             GtkWidget      *toolbar,
                             int             position,
                             MooToolItemFlags flags)
{
    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, flags);
}


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_name (MooAction *action)
{
    g_return_val_if_fail (MOO_IS_ACTION (action), NULL);
    return action->group_name;
}

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_make_accel_path (const char     *group_id,
                            const char     *action_id)
{
    static GString *path = NULL;

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

    if (!path)
        path = g_string_new (NULL);

    if (group_id && group_id[0])
        g_string_printf (path, "<MooAction>/%s/%s", group_id, action_id);
    else
        g_string_printf (path, "<MooAction>/%s", action_id);

    return path->str;
}


static GtkWidget*
moo_action_create_menu_item_real (MooAction *action)
{
    GtkWidget *item = NULL;

    if (action->dead)
    {
        return NULL;
    }
    else 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));

    if (action->force_accel_label)
    {
        GtkWidget *accel_label = gtk_bin_get_child (GTK_BIN (item));

        if (GTK_IS_ACCEL_LABEL (accel_label))
            moo_accel_label_set_action (accel_label, action);
        else
            g_critical ("%s: oops", G_STRLOC);
    }

    moo_action_add_proxy (action, item);

    return item;
}


static GtkWidget*
moo_action_create_tool_item_real (MooAction      *action,
                                  GtkWidget      *toolbar,
                                  int             position,
                                  MooToolItemFlags flags)
{
#if GTK_CHECK_VERSION(2,4,0)
    GtkToolItem *item = NULL;

    if (action->stock_id)
    {
#if GTK_CHECK_VERSION(2,6,0)
        if (flags & MOO_TOOL_ITEM_MENU)
            item = gtk_menu_tool_button_new_from_stock (action->stock_id);
        else
#endif
            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 (GTK_TOOLBAR (toolbar)));
            if (!icon)
                g_warning ("could not create stock icon '%s'",
                           action->icon_stock_id);
            else
                gtk_widget_show (icon);
        }

#if GTK_CHECK_VERSION(2,6,0)
        if (flags & MOO_TOOL_ITEM_MENU)
            item = gtk_menu_tool_button_new (icon, action->label);
        else
#endif
            item = gtk_tool_button_new (icon, action->label);

        gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE);
    }

    if (action->tooltip)
        moo_widget_set_tooltip (GTK_WIDGET (item), action->tooltip);

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

#else /*  !GTK_CHECK_VERSION(2,4,0) */

    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_CHECK_VERSION(2,4,0) */

    moo_action_add_proxy (action, GTK_WIDGET (item));

    return GTK_WIDGET (item);
}


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 ? TRUE : FALSE);
}

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 ? TRUE : FALSE);
}


static void
moo_action_set_sensitive_real (MooAction      *action,
                               gboolean        sensitive)
{
    g_return_if_fail (MOO_IS_ACTION (action));
    action->sensitive = sensitive ? TRUE : FALSE;
    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 ? TRUE : FALSE;
    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)
    {
        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 moo_action_add_proxy        (MooAction      *action,
                                         GtkWidget      *proxy)
{
    g_return_if_fail (MOO_IS_ACTION (action));
    g_return_if_fail (G_IS_OBJECT (proxy));

    if (GTK_IS_MENU_ITEM (proxy))
    {
        moo_bind_signal (action, "activate", proxy, "activate");
    }
#if GTK_MINOR_VERSION >= 4
    else if (GTK_IS_TOOL_BUTTON (proxy))
    {
        moo_bind_signal (action, "activate", proxy, "clicked");
        moo_bind_bool_property (proxy, "is-important", action, "is-important", FALSE);
    }
#endif /* GTK_MINOR_VERSION >= 4 */
    else if (GTK_IS_BUTTON (proxy))
    {
        moo_bind_signal (action, "activate", proxy, "clicked");
    }
    else
    {
        g_warning ("%s: unknown proxy type '%s'", G_STRLOC,
                   g_type_name (G_OBJECT_TYPE (proxy)));
    }

    moo_bind_bool_property (proxy, "sensitive", action, "sensitive", FALSE);
    moo_bind_bool_property (proxy, "visible", action, "visible", FALSE);
}


const char*
moo_action_get_default_accel (MooAction      *action)
{
    g_return_val_if_fail (MOO_IS_ACTION (action), "");

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

    return action->default_accel;
}


void
_moo_action_set_accel_path (MooAction      *action,
                            const char     *accel_path)
{
    g_return_if_fail (MOO_IS_ACTION (action));
    g_free (action->accel_path);
    action->accel_path = g_strdup (accel_path);
}


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


const char*
_moo_action_get_accel (MooAction *action)
{
    g_return_val_if_fail (MOO_IS_ACTION (action), "");

    if (action->accel_path)
        return moo_get_accel (action->accel_path);
    else if (action->default_accel)
        return action->default_accel;
    else
        return "";
}


GType
moo_tool_item_flags_get_type (void)
{
    static GType type = 0;

    if (!type)
    {
        static const GFlagsValue values[] = {
            { MOO_TOOL_ITEM_MENU, (char*) "MOO_TOOL_ITEM_MENU", (char*) "menu" },
            { 0, NULL, NULL }
        };

        type = g_flags_register_static ("MooToolItemFlags", values);
    }

    return type;
}