697 lines
23 KiB
C
697 lines
23 KiB
C
/*
|
|
* 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-private.h"
|
|
#include "mooutils/mooactionbase-private.h"
|
|
#include "mooutils/mooutils-gobject.h"
|
|
#include "mooutils/mooactiongroup.h"
|
|
#include <string.h>
|
|
|
|
|
|
gpointer
|
|
_moo_action_get_window (gpointer action)
|
|
{
|
|
GtkActionGroup *group;
|
|
MooActionCollection *collection;
|
|
|
|
g_return_val_if_fail (GTK_IS_ACTION (action), NULL);
|
|
|
|
group = _moo_action_get_group (action);
|
|
g_return_val_if_fail (MOO_IS_ACTION_GROUP (group), NULL);
|
|
|
|
collection = _moo_action_group_get_collection (MOO_ACTION_GROUP (group));
|
|
return _moo_action_collection_get_window (collection);
|
|
}
|
|
|
|
|
|
#define DEFINE_ACTION_TYPE(TypeName, type_name, TYPE_PARENT) \
|
|
\
|
|
static void type_name##_init (TypeName *self); \
|
|
static void type_name##_class_init (TypeName##Class *klass); \
|
|
static void type_name##_set_property (GObject *object, \
|
|
guint property_id, \
|
|
const GValue *value, \
|
|
GParamSpec *pspec); \
|
|
static void type_name##_get_property (GObject *object, \
|
|
guint property_id, \
|
|
GValue *value, \
|
|
GParamSpec *pspec); \
|
|
static gpointer type_name##_parent_class = NULL; \
|
|
\
|
|
static void \
|
|
type_name##_class_intern_init (gpointer klass) \
|
|
{ \
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass); \
|
|
\
|
|
object_class->set_property = type_name##_set_property; \
|
|
object_class->get_property = type_name##_get_property; \
|
|
_moo_action_base_init_class (object_class); \
|
|
\
|
|
type_name##_parent_class = g_type_class_peek_parent (klass); \
|
|
type_name##_class_init ((TypeName##Class*) klass); \
|
|
} \
|
|
\
|
|
GType \
|
|
type_name##_get_type (void) \
|
|
{ \
|
|
static GType type; \
|
|
\
|
|
if (!type) \
|
|
{ \
|
|
static const GTypeInfo info = { \
|
|
sizeof (TypeName##Class), \
|
|
(GBaseInitFunc) NULL, \
|
|
(GBaseFinalizeFunc) NULL, \
|
|
(GClassInitFunc) type_name##_class_intern_init, \
|
|
(GClassFinalizeFunc) NULL, \
|
|
NULL, /* class_data */ \
|
|
sizeof (TypeName), \
|
|
0, /* n_preallocs */ \
|
|
(GInstanceInitFunc) type_name##_init, \
|
|
NULL /* value_table */ \
|
|
}; \
|
|
\
|
|
static const GInterfaceInfo iface_info; \
|
|
\
|
|
type = g_type_register_static (TYPE_PARENT, \
|
|
#TypeName, \
|
|
&info, 0); \
|
|
g_type_add_interface_static (type, \
|
|
MOO_TYPE_ACTION_BASE, \
|
|
&iface_info); \
|
|
} \
|
|
\
|
|
return type; \
|
|
}
|
|
|
|
|
|
DEFINE_ACTION_TYPE (MooAction, moo_action, GTK_TYPE_ACTION)
|
|
DEFINE_ACTION_TYPE (MooToggleAction, moo_toggle_action, GTK_TYPE_TOGGLE_ACTION)
|
|
DEFINE_ACTION_TYPE (MooRadioAction, moo_radio_action, GTK_TYPE_RADIO_ACTION)
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* MooAction
|
|
*/
|
|
|
|
struct _MooActionPrivate {
|
|
MooClosure *closure;
|
|
};
|
|
|
|
enum {
|
|
MOO_ACTION_BASE_PROPS(ACTION),
|
|
ACTION_PROP_CLOSURE,
|
|
ACTION_PROP_CLOSURE_OBJECT,
|
|
ACTION_PROP_CLOSURE_SIGNAL,
|
|
ACTION_PROP_CLOSURE_CALLBACK,
|
|
ACTION_PROP_CLOSURE_PROXY_FUNC
|
|
};
|
|
|
|
|
|
static void
|
|
moo_action_init (MooAction *action)
|
|
{
|
|
action->priv = g_new0 (MooActionPrivate, 1);
|
|
}
|
|
|
|
|
|
static void
|
|
moo_action_dispose (GObject *object)
|
|
{
|
|
MooAction *action = MOO_ACTION (object);
|
|
|
|
if (action->priv)
|
|
{
|
|
if (action->priv->closure)
|
|
{
|
|
moo_closure_unref (action->priv->closure);
|
|
action->priv->closure = NULL;
|
|
}
|
|
|
|
g_free (action->priv);
|
|
action->priv = NULL;
|
|
}
|
|
|
|
G_OBJECT_CLASS (moo_action_parent_class)->dispose (object);
|
|
}
|
|
|
|
|
|
static void
|
|
moo_action_activate (GtkAction *gtkaction)
|
|
{
|
|
MooAction *action = MOO_ACTION (gtkaction);
|
|
|
|
if (action->priv->closure)
|
|
moo_closure_invoke (action->priv->closure);
|
|
}
|
|
|
|
|
|
static GObject *
|
|
moo_action_constructor (GType type,
|
|
guint n_props,
|
|
GObjectConstructParam *props)
|
|
{
|
|
guint i;
|
|
GObject *object;
|
|
MooClosure *closure = NULL;
|
|
gpointer closure_object = NULL;
|
|
const char *closure_signal = NULL;
|
|
GCallback closure_callback = NULL;
|
|
GCallback closure_proxy_func = NULL;
|
|
|
|
for (i = 0; i < n_props; ++i)
|
|
{
|
|
const char *name = props[i].pspec->name;
|
|
GValue *value = props[i].value;
|
|
|
|
if (!strcmp (name, "closure-object"))
|
|
closure_object = g_value_get_object (value);
|
|
else if (!strcmp (name, "closure-signal"))
|
|
closure_signal = g_value_get_string (value);
|
|
else if (!strcmp (name, "closure-callback"))
|
|
closure_callback = g_value_get_pointer (value);
|
|
else if (!strcmp (name, "closure-proxy-func"))
|
|
closure_proxy_func = g_value_get_pointer (value);
|
|
}
|
|
|
|
if (closure_callback || closure_signal)
|
|
{
|
|
if (closure_object)
|
|
{
|
|
closure = moo_closure_new_simple (closure_object, closure_signal,
|
|
closure_callback, closure_proxy_func);
|
|
moo_closure_ref_sink (closure);
|
|
}
|
|
else
|
|
g_critical ("%s: closure data missing", G_STRLOC);
|
|
}
|
|
|
|
object = G_OBJECT_CLASS(moo_action_parent_class)->constructor (type, n_props, props);
|
|
|
|
if (closure)
|
|
{
|
|
_moo_action_set_closure (MOO_ACTION (object), closure);
|
|
moo_closure_unref (closure);
|
|
}
|
|
|
|
return object;
|
|
}
|
|
|
|
|
|
static void
|
|
moo_action_class_init (MooActionClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
GtkActionClass *action_class = GTK_ACTION_CLASS (klass);
|
|
|
|
object_class->dispose = moo_action_dispose;
|
|
object_class->constructor = moo_action_constructor;
|
|
action_class->activate = moo_action_activate;
|
|
|
|
g_object_class_install_property (object_class, ACTION_PROP_CLOSURE,
|
|
g_param_spec_boxed ("closure", "closure", "closure",
|
|
MOO_TYPE_CLOSURE,
|
|
G_PARAM_READWRITE));
|
|
g_object_class_install_property (object_class, ACTION_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 (object_class, ACTION_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 (object_class, ACTION_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 (object_class, ACTION_PROP_CLOSURE_PROXY_FUNC,
|
|
g_param_spec_pointer ("closure-proxy-func", "closure-proxy-func", "closure-proxy-func",
|
|
G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
|
|
}
|
|
|
|
|
|
static void
|
|
moo_action_set_property (GObject *object,
|
|
guint property_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
MooAction *action = MOO_ACTION (object);
|
|
|
|
switch (property_id)
|
|
{
|
|
case ACTION_PROP_CLOSURE:
|
|
_moo_action_set_closure (action, g_value_get_boxed (value));
|
|
break;
|
|
|
|
case ACTION_PROP_CLOSURE_OBJECT:
|
|
case ACTION_PROP_CLOSURE_SIGNAL:
|
|
case ACTION_PROP_CLOSURE_CALLBACK:
|
|
case ACTION_PROP_CLOSURE_PROXY_FUNC:
|
|
/* these are handled in the constructor */
|
|
break;
|
|
|
|
MOO_ACTION_BASE_SET_PROPERTY (ACTION);
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
moo_action_get_property (GObject *object,
|
|
guint property_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
MooAction *action = MOO_ACTION (object);
|
|
|
|
switch (property_id)
|
|
{
|
|
case ACTION_PROP_CLOSURE:
|
|
g_value_set_boxed (value, action->priv->closure);
|
|
break;
|
|
|
|
MOO_ACTION_BASE_GET_PROPERTY (ACTION);
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
_moo_action_set_closure (MooAction *action,
|
|
MooClosure *closure)
|
|
{
|
|
g_return_if_fail (MOO_IS_ACTION (action));
|
|
|
|
if (closure == action->priv->closure)
|
|
return;
|
|
|
|
if (action->priv->closure)
|
|
moo_closure_unref (action->priv->closure);
|
|
if (closure)
|
|
moo_closure_ref_sink (closure);
|
|
|
|
action->priv->closure = closure;
|
|
g_object_notify (G_OBJECT (action), "closure");
|
|
}
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* MooToggleAction
|
|
*/
|
|
|
|
struct _MooToggleActionPrivate {
|
|
MooToggleActionCallback callback;
|
|
MooObjectPtr *ptr;
|
|
gpointer data;
|
|
};
|
|
|
|
enum {
|
|
MOO_ACTION_BASE_PROPS(TOGGLE_ACTION),
|
|
TOGGLE_ACTION_PROP_TOGGLED_CALLBACK,
|
|
TOGGLE_ACTION_PROP_TOGGLED_OBJECT,
|
|
TOGGLE_ACTION_PROP_TOGGLED_DATA
|
|
};
|
|
|
|
|
|
static void
|
|
moo_toggle_action_init (MooToggleAction *action)
|
|
{
|
|
action->priv = g_new0 (MooToggleActionPrivate, 1);
|
|
}
|
|
|
|
|
|
static void
|
|
moo_toggle_action_dispose (GObject *object)
|
|
{
|
|
MooToggleAction *action = MOO_TOGGLE_ACTION (object);
|
|
|
|
if (action->priv->ptr)
|
|
{
|
|
moo_object_ptr_free (action->priv->ptr);
|
|
action->priv->ptr = NULL;
|
|
}
|
|
|
|
G_OBJECT_CLASS (moo_toggle_action_parent_class)->dispose (object);
|
|
}
|
|
|
|
|
|
static void
|
|
moo_toggle_action_toggled (GtkToggleAction *gtkaction)
|
|
{
|
|
MooToggleAction *action = MOO_TOGGLE_ACTION (gtkaction);
|
|
|
|
if (action->priv->callback)
|
|
{
|
|
if (MOO_OBJECT_PTR_GET (action->priv->ptr))
|
|
{
|
|
GObject *obj = MOO_OBJECT_PTR_GET (action->priv->ptr);
|
|
g_object_ref (obj);
|
|
action->priv->callback (obj, gtk_toggle_action_get_active (gtkaction));
|
|
g_object_unref (obj);
|
|
}
|
|
else
|
|
{
|
|
action->priv->callback (action->priv->data, gtk_toggle_action_get_active (gtkaction));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static GObject *
|
|
moo_toggle_action_constructor (GType type,
|
|
guint n_props,
|
|
GObjectConstructParam *props)
|
|
{
|
|
guint i;
|
|
GObject *object;
|
|
MooToggleAction *action;
|
|
MooToggleActionCallback toggled_callback = NULL;
|
|
gpointer toggled_data = NULL;
|
|
gpointer toggled_object = NULL;
|
|
|
|
for (i = 0; i < n_props; ++i)
|
|
{
|
|
const char *name = props[i].pspec->name;
|
|
GValue *value = props[i].value;
|
|
|
|
if (!strcmp (name, "toggled-callback"))
|
|
toggled_callback = g_value_get_pointer (value);
|
|
else if (!strcmp (name, "toggled-data"))
|
|
toggled_data = g_value_get_pointer (value);
|
|
else if (!strcmp (name, "toggled-object"))
|
|
toggled_object = g_value_get_object (value);
|
|
}
|
|
|
|
object = G_OBJECT_CLASS(moo_toggle_action_parent_class)->constructor (type, n_props, props);
|
|
action = MOO_TOGGLE_ACTION (object);
|
|
|
|
if (toggled_callback)
|
|
{
|
|
if (toggled_object)
|
|
_moo_toggle_action_set_callback (action, toggled_callback, toggled_object, TRUE);
|
|
else
|
|
_moo_toggle_action_set_callback (action, toggled_callback, toggled_data, FALSE);
|
|
}
|
|
|
|
return object;
|
|
}
|
|
|
|
|
|
void
|
|
_moo_toggle_action_set_callback (MooToggleAction *action,
|
|
MooToggleActionCallback callback,
|
|
gpointer data,
|
|
gboolean object)
|
|
{
|
|
g_return_if_fail (MOO_IS_TOGGLE_ACTION (action));
|
|
g_return_if_fail (!object || G_IS_OBJECT (data));
|
|
|
|
action->priv->callback = callback;
|
|
if (action->priv->ptr)
|
|
moo_object_ptr_free (action->priv->ptr);
|
|
action->priv->ptr = NULL;
|
|
action->priv->data = NULL;
|
|
|
|
if (callback)
|
|
{
|
|
if (object)
|
|
action->priv->ptr = moo_object_ptr_new (data, NULL, NULL);
|
|
else
|
|
action->priv->data = data;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
moo_toggle_action_class_init (MooToggleActionClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
GtkToggleActionClass *action_class = GTK_TOGGLE_ACTION_CLASS (klass);
|
|
|
|
object_class->dispose = moo_toggle_action_dispose;
|
|
object_class->constructor = moo_toggle_action_constructor;
|
|
action_class->toggled = moo_toggle_action_toggled;
|
|
|
|
g_object_class_install_property (object_class, TOGGLE_ACTION_PROP_TOGGLED_CALLBACK,
|
|
g_param_spec_pointer ("toggled-callback", "toggled-callback", "toggled-callback",
|
|
G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
|
|
g_object_class_install_property (object_class, TOGGLE_ACTION_PROP_TOGGLED_OBJECT,
|
|
g_param_spec_object ("toggled-object", "toggled-object", "toggled-object",
|
|
G_TYPE_OBJECT, G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
|
|
g_object_class_install_property (object_class, TOGGLE_ACTION_PROP_TOGGLED_DATA,
|
|
g_param_spec_pointer ("toggled-data", "toggled-data", "toggled-data",
|
|
G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
|
|
}
|
|
|
|
|
|
static void
|
|
moo_toggle_action_set_property (GObject *object,
|
|
guint property_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
switch (property_id)
|
|
{
|
|
case TOGGLE_ACTION_PROP_TOGGLED_CALLBACK:
|
|
case TOGGLE_ACTION_PROP_TOGGLED_OBJECT:
|
|
case TOGGLE_ACTION_PROP_TOGGLED_DATA:
|
|
/* these are handled in the constructor */
|
|
break;
|
|
|
|
MOO_ACTION_BASE_SET_PROPERTY (TOGGLE_ACTION);
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
moo_toggle_action_get_property (GObject *object,
|
|
guint property_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
switch (property_id)
|
|
{
|
|
MOO_ACTION_BASE_GET_PROPERTY (TOGGLE_ACTION);
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
|
}
|
|
}
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* MooRadioAction
|
|
*/
|
|
|
|
enum {
|
|
MOO_ACTION_BASE_PROPS(RADIO_ACTION)
|
|
};
|
|
|
|
|
|
static void
|
|
moo_radio_action_init (G_GNUC_UNUSED MooRadioAction *action)
|
|
{
|
|
}
|
|
|
|
|
|
static void
|
|
moo_radio_action_class_init (G_GNUC_UNUSED MooRadioActionClass *klass)
|
|
{
|
|
}
|
|
|
|
|
|
static void
|
|
moo_radio_action_set_property (GObject *object,
|
|
guint property_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
switch (property_id)
|
|
{
|
|
MOO_ACTION_BASE_SET_PROPERTY (RADIO_ACTION);
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
moo_radio_action_get_property (GObject *object,
|
|
guint property_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
switch (property_id)
|
|
{
|
|
MOO_ACTION_BASE_GET_PROPERTY (RADIO_ACTION);
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
|
}
|
|
}
|
|
|
|
|
|
/**************************************************************************/
|
|
/* _moo_sync_toggle_action
|
|
*/
|
|
|
|
typedef struct {
|
|
MooObjectWatch parent;
|
|
GParamSpec *pspec;
|
|
gboolean invert;
|
|
} ToggleWatch;
|
|
|
|
static void action_toggled (ToggleWatch *watch);
|
|
static void prop_changed (ToggleWatch *watch);
|
|
static void toggle_watch_destroy (MooObjectWatch *watch);
|
|
|
|
static MooObjectWatchClass ToggleWatchClass = {NULL, NULL, toggle_watch_destroy};
|
|
|
|
|
|
static ToggleWatch *
|
|
toggle_watch_new (GObject *master,
|
|
const char *prop,
|
|
GtkAction *action,
|
|
gboolean invert)
|
|
{
|
|
ToggleWatch *watch;
|
|
GObjectClass *klass;
|
|
GParamSpec *pspec;
|
|
char *signal;
|
|
|
|
g_return_val_if_fail (G_IS_OBJECT (master), NULL);
|
|
g_return_val_if_fail (GTK_IS_TOGGLE_ACTION (action), NULL);
|
|
g_return_val_if_fail (prop != NULL, NULL);
|
|
|
|
klass = g_type_class_peek (G_OBJECT_TYPE (master));
|
|
pspec = g_object_class_find_property (klass, prop);
|
|
|
|
if (!pspec)
|
|
{
|
|
g_warning ("%s: no property '%s' in class '%s'",
|
|
G_STRLOC, prop, g_type_name (G_OBJECT_TYPE (master)));
|
|
return NULL;
|
|
}
|
|
|
|
watch = _moo_object_watch_new (ToggleWatch, &ToggleWatchClass,
|
|
master, action, NULL, NULL);
|
|
|
|
watch->pspec = pspec;
|
|
watch->invert = invert;
|
|
|
|
signal = g_strdup_printf ("notify::%s", prop);
|
|
|
|
g_signal_connect_swapped (master, signal,
|
|
G_CALLBACK (prop_changed),
|
|
watch);
|
|
g_signal_connect_swapped (action, "toggled",
|
|
G_CALLBACK (action_toggled),
|
|
watch);
|
|
|
|
g_free (signal);
|
|
return watch;
|
|
}
|
|
|
|
|
|
static void
|
|
toggle_watch_destroy (MooObjectWatch *watch)
|
|
{
|
|
if (MOO_OBJECT_PTR_GET (watch->source))
|
|
{
|
|
g_signal_handlers_disconnect_by_func (MOO_OBJECT_PTR_GET (watch->source),
|
|
(gpointer) prop_changed,
|
|
watch);
|
|
}
|
|
|
|
if (MOO_OBJECT_PTR_GET (watch->target))
|
|
{
|
|
g_assert (GTK_IS_TOGGLE_ACTION (MOO_OBJECT_PTR_GET (watch->target)));
|
|
g_signal_handlers_disconnect_by_func (MOO_OBJECT_PTR_GET (watch->target),
|
|
(gpointer) action_toggled,
|
|
watch);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
_moo_sync_toggle_action (GtkAction *action,
|
|
gpointer master,
|
|
const char *prop,
|
|
gboolean invert)
|
|
{
|
|
ToggleWatch *watch;
|
|
|
|
g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
|
|
g_return_if_fail (G_IS_OBJECT (master));
|
|
g_return_if_fail (prop != NULL);
|
|
|
|
watch = toggle_watch_new (master, prop, action, invert);
|
|
g_return_if_fail (watch != NULL);
|
|
|
|
prop_changed (watch);
|
|
}
|
|
|
|
|
|
static void
|
|
prop_changed (ToggleWatch *watch)
|
|
{
|
|
gboolean value, active, equal;
|
|
gpointer action;
|
|
|
|
g_object_get (MOO_OBJECT_PTR_GET (watch->parent.source),
|
|
watch->pspec->name, &value, NULL);
|
|
|
|
action = MOO_OBJECT_PTR_GET (watch->parent.target);
|
|
g_assert (GTK_IS_TOGGLE_ACTION (action));
|
|
active = gtk_toggle_action_get_active (action);
|
|
|
|
if (!watch->invert)
|
|
equal = !value == !active;
|
|
else
|
|
equal = !value != !active;
|
|
|
|
if (!equal)
|
|
gtk_toggle_action_set_active (action, watch->invert ? !value : value);
|
|
}
|
|
|
|
|
|
static void
|
|
action_toggled (ToggleWatch *watch)
|
|
{
|
|
gboolean value, active, equal;
|
|
gpointer action;
|
|
|
|
g_object_get (MOO_OBJECT_PTR_GET (watch->parent.source),
|
|
watch->pspec->name, &value, NULL);
|
|
|
|
action = MOO_OBJECT_PTR_GET (watch->parent.target);
|
|
g_assert (GTK_IS_TOGGLE_ACTION (action));
|
|
active = gtk_toggle_action_get_active (action);
|
|
|
|
if (!watch->invert)
|
|
equal = !value == !active;
|
|
else
|
|
equal = !value != !active;
|
|
|
|
if (!equal)
|
|
g_object_set (MOO_OBJECT_PTR_GET (watch->parent.source),
|
|
watch->pspec->name,
|
|
watch->invert ? !active : active, NULL);
|
|
}
|