=?utf-8?q?=5Bglib-controller=5D_Rename_GControllerReference_=E2=86=92_GCo?= =?utf-8?q?ntrollerEvent?=
- From: Emmanuele Bassi <ebassi src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [glib-controller] Rename GControllerReference â GControllerEvent
- Date: Mon, 12 Sep 2011 17:40:13 +0000 (UTC)
commit 1c3428faf6bbcc770db9b43c87ef3a9fbdadaf73
Author: Emmanuele Bassi <ebassi linux intel com>
Date: Mon Sep 12 17:54:51 2011 +0100
Rename GControllerReference â GControllerEvent
The terminology is confusing: a GControllerReference is not a reference
on the controller, but an "event" that was reported to the various
listeners.
Makefile.am | 4 +-
doc/reference/glib-controller-docs.xml | 2 +-
doc/reference/glib-controller-sections.txt | 52 ++--
doc/reference/glib-controller.types | 2 +-
examples/simple-model.c | 24 +-
glib-controller/gcontroller.c | 155 ++++----
glib-controller/gcontroller.h | 51 +--
glib-controller/gcontrollerevent.c | 577 +++++++++++++++++++++++++++
glib-controller/gcontrollerevent.h | 80 ++++
glib-controller/gcontrollerreference.c | 584 ----------------------------
glib-controller/gcontrollerreference.h | 80 ----
glib-controller/gcontrollertypes.h | 12 +-
glib-controller/glib-controller.h | 2 +-
glib-controller/tests/array-controller.c | 40 +-
glib-controller/tests/hash-controller.c | 32 +-
15 files changed, 843 insertions(+), 854 deletions(-)
---
diff --git a/Makefile.am b/Makefile.am
index 8e230ca..30c5c67 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -38,7 +38,7 @@ lib_LTLIBRARIES += libglib-controller-1.0.la
source_c = \
glib-controller/garraycontroller.c \
- glib-controller/gcontrollerreference.c \
+ glib-controller/gcontrollerevent.c \
glib-controller/gcontroller.c \
glib-controller/ghashcontroller.c \
glib-controller/gptrarraycontroller.c \
@@ -46,7 +46,7 @@ source_c = \
source_public_h = \
glib-controller/garraycontroller.h \
- glib-controller/gcontrollerreference.h \
+ glib-controller/gcontrollerevent.h \
glib-controller/gcontrollertypes.h \
glib-controller/gcontroller.h \
glib-controller/ghashcontroller.h \
diff --git a/doc/reference/glib-controller-docs.xml b/doc/reference/glib-controller-docs.xml
index adc530c..77a776d 100644
--- a/doc/reference/glib-controller-docs.xml
+++ b/doc/reference/glib-controller-docs.xml
@@ -18,7 +18,7 @@
<title>Base Classes</title>
<xi:include href="xml/gcontroller.xml"/>
- <xi:include href="xml/gcontrollerreference.xml"/>
+ <xi:include href="xml/gcontrollerevent.xml"/>
</chapter>
<chapter>
diff --git a/doc/reference/glib-controller-sections.txt b/doc/reference/glib-controller-sections.txt
index 323029b..cf2df79 100644
--- a/doc/reference/glib-controller-sections.txt
+++ b/doc/reference/glib-controller-sections.txt
@@ -48,8 +48,8 @@ GPtrArrayControllerPrivate
GController
GControllerClass
GControllerAction
-g_controller_create_reference
-g_controller_create_referencev
+g_controller_create_event
+g_controller_create_eventv
g_controller_emit_changed
<SUBSECTION Standard>
@@ -85,38 +85,38 @@ GArrayControllerPrivate
</SECTION>
<SECTION>
-<FILE>gcontrollerreference</FILE>
-<TITLE>GControllerReference</TITLE>
-GControllerReference
-GControllerReferenceClass
-g_controller_reference_get_controller
-g_controller_reference_get_action
-g_controller_reference_get_n_indices
-g_controller_reference_get_index_type
+<FILE>gcontrollerevent</FILE>
+<TITLE>GControllerEvent</TITLE>
+GControllerEvent
+GControllerEventClass
+g_controller_event_get_controller
+g_controller_event_get_action
+g_controller_event_get_n_indices
+g_controller_event_get_index_type
<SUBSECTION>
-g_controller_reference_add_index_value
-g_controller_reference_get_index_value
-g_controller_reference_add_index
-g_controller_reference_get_index
+g_controller_event_add_index_value
+g_controller_event_get_index_value
+g_controller_event_add_index
+g_controller_event_get_index
<SUBSECTION>
-g_controller_reference_get_index_int
-g_controller_reference_get_index_uint
-g_controller_reference_get_index_string
-g_controller_reference_get_index_pointer
+g_controller_event_get_index_int
+g_controller_event_get_index_uint
+g_controller_event_get_index_string
+g_controller_event_get_index_pointer
<SUBSECTION Standard>
-g_controller_reference_get_type
-G_CONTROLLER_REFERENCE
-G_IS_CONTROLLER_REFERENCE
-G_CONTROLLER_REFERENCE_CLASS
-G_IS_CONTROLLER_REFERENCE_CLASS
-G_CONTROLLER_REFERENCE_GET_CLASS
-G_TYPE_CONTROLLER_REFERENCE
+g_controller_event_get_type
+G_CONTROLLER_EVENT
+G_IS_CONTROLLER_EVENT
+G_CONTROLLER_EVENT_CLASS
+G_IS_CONTROLLER_EVENT_CLASS
+G_CONTROLLER_EVENT_GET_CLASS
+G_TYPE_CONTROLLER_EVENT
<SUBSECTION Private>
-GControllerReferencePrivate
+GControllerEventPrivate
</SECTION>
<SECTION>
diff --git a/doc/reference/glib-controller.types b/doc/reference/glib-controller.types
index c43c6da..459e045 100644
--- a/doc/reference/glib-controller.types
+++ b/doc/reference/glib-controller.types
@@ -1,5 +1,5 @@
g_array_controller_get_type
g_controller_get_type
-g_controller_reference_get_type
+g_controller_event_get_type
g_hash_controller_get_type
g_ptr_array_controller_get_type
diff --git a/examples/simple-model.c b/examples/simple-model.c
index a90fe88..a756def 100644
--- a/examples/simple-model.c
+++ b/examples/simple-model.c
@@ -78,14 +78,14 @@ void
my_simple_model_add_text (MySimpleModel *model,
const gchar *text)
{
- GControllerReference *ref;
+ GControllerEvent *ref;
g_return_if_fail (MY_IS_SIMPLE_MODEL (model));
g_return_if_fail (text != NULL && text[0] != '\0');
g_ptr_array_add (model->array, g_strdup (text));
- ref = g_controller_create_reference (model->controller, G_CONTROLLER_ADD,
+ ref = g_controller_create_event (model->controller, G_CONTROLLER_ADD,
G_TYPE_UINT, 1,
model->array->len - 1);
g_controller_emit_changed (model->controller, ref);
@@ -96,7 +96,7 @@ void
my_simple_model_remove_text (MySimpleModel *model,
const gchar *text)
{
- GControllerReference *ref;
+ GControllerEvent *ref;
gint i, pos;
g_return_if_fail (MY_IS_SIMPLE_MODEL (model));
@@ -115,7 +115,7 @@ my_simple_model_remove_text (MySimpleModel *model,
if (pos == -1)
return;
- ref = g_controller_create_reference (model->controller, G_CONTROLLER_REMOVE,
+ ref = g_controller_create_event (model->controller, G_CONTROLLER_REMOVE,
G_TYPE_UINT, 1,
pos);
g_controller_emit_changed (model->controller, ref);
@@ -146,7 +146,7 @@ my_simple_model_set_items (MySimpleModel *model,
gint n_strings,
const gchar * const text[])
{
- GControllerReference *ref;
+ GControllerEvent *ref;
GPtrArray *array;
gint i;
@@ -158,7 +158,7 @@ my_simple_model_set_items (MySimpleModel *model,
g_ptr_array_controller_set_array (G_PTR_ARRAY_CONTROLLER (model->controller), array);
- ref = g_controller_create_reference (model->controller, G_CONTROLLER_REPLACE,
+ ref = g_controller_create_event (model->controller, G_CONTROLLER_REPLACE,
G_TYPE_UINT, 0);
g_controller_emit_changed (model->controller, ref);
g_object_unref (ref);
@@ -167,7 +167,7 @@ my_simple_model_set_items (MySimpleModel *model,
void
my_simple_model_clear (MySimpleModel *model)
{
- GControllerReference *ref;
+ GControllerEvent *ref;
GPtrArray *array;
g_return_if_fail (MY_IS_SIMPLE_MODEL (model));
@@ -176,7 +176,7 @@ my_simple_model_clear (MySimpleModel *model)
g_ptr_array_controller_set_array (G_PTR_ARRAY_CONTROLLER (model->controller), array);
model->array = array;
- ref = g_controller_create_reference (model->controller, G_CONTROLLER_CLEAR,
+ ref = g_controller_create_event (model->controller, G_CONTROLLER_CLEAR,
G_TYPE_UINT, 0);
g_controller_emit_changed (model->controller, ref);
g_object_unref (ref);
@@ -203,19 +203,19 @@ my_simple_model_get_controller (MySimpleModel *model)
static void
on_model_changed (GController *controller,
GControllerAction action,
- GControllerReference *ref,
+ GControllerEvent *ref,
MySimpleModel *model)
{
gint i, n_indices;
- n_indices = g_controller_reference_get_n_indices (ref);
+ n_indices = g_controller_event_get_n_indices (ref);
switch (action)
{
case G_CONTROLLER_ADD:
for (i = 0; i < n_indices; i++)
{
- gint idx = g_controller_reference_get_index_uint (ref, i);
+ gint idx = g_controller_event_get_index_uint (ref, i);
const gchar *text;
text = my_simple_model_get_text (model, idx);
@@ -228,7 +228,7 @@ on_model_changed (GController *controller,
case G_CONTROLLER_REMOVE:
for (i = 0; i < n_indices; i++)
{
- gint idx = g_controller_reference_get_index_uint (ref, i);
+ gint idx = g_controller_event_get_index_uint (ref, i);
const gchar *text;
text = my_simple_model_get_text (model, idx);
diff --git a/glib-controller/gcontroller.c b/glib-controller/gcontroller.c
index 04c22a8..fab1a5f 100644
--- a/glib-controller/gcontroller.c
+++ b/glib-controller/gcontroller.c
@@ -15,14 +15,13 @@
* <listitem><simpara>where to access the changed data</simpara></listitem>
* </itemizedlist>
*/
-#ifdef HAVE_CONFIG_H
+
#include "config.h"
-#endif
#include "gcontroller.h"
#include "gcontrollerenumtypes.h"
#include "gcontrollermarshal.h"
-#include "gcontrollerreference.h"
+#include "gcontrollerevent.h"
#include <string.h>
#include <gobject/gvaluecollector.h>
@@ -38,15 +37,15 @@ static guint controller_signals[LAST_SIGNAL] = { 0, };
G_DEFINE_ABSTRACT_TYPE (GController, g_controller, G_TYPE_OBJECT);
-static GControllerReference *
-create_reference (GController *controller,
- GControllerAction action,
- GType index_type,
- GValueArray *indices)
+static GControllerEvent *
+create_event (GController *controller,
+ GControllerAction action,
+ GType index_type,
+ GValueArray *indices)
{
g_assert (index_type != G_TYPE_INVALID);
- return g_object_new (G_TYPE_CONTROLLER_REFERENCE,
+ return g_object_new (G_TYPE_CONTROLLER_EVENT,
"controller", controller,
"action", action,
"index-type", index_type,
@@ -57,20 +56,20 @@ create_reference (GController *controller,
static void
g_controller_class_init (GControllerClass *klass)
{
- klass->create_reference = create_reference;
+ klass->create_event = create_event;
/**
* GController::changed:
* @controller: the #GController that emitted the signal
* @action: the action on the data storage controlled by @controller
- * @reference: a reference to the indices changed
+ * @event: a reference to the indices changed
*
* The ::changed signal is emitted each time the data storage controlled
* by a #GController instance changes. The type of change is detailed by
* the #GControllerAction enumeration and passed as the @action argument
* to the signal handlers.
*
- * The @reference object contains the information necessary for retrieving
+ * The @event object contains the information necessary for retrieving
* the data that was affected by the change from the controlled storage;
* the type of the information depends on the #GController.
*
@@ -87,7 +86,7 @@ g_controller_class_init (GControllerClass *klass)
_gcontroller_marshal_VOID__ENUM_OBJECT,
G_TYPE_NONE, 2,
G_TYPE_CONTROLLER_ACTION,
- G_TYPE_CONTROLLER_REFERENCE);
+ G_TYPE_CONTROLLER_EVENT);
}
static void
@@ -95,75 +94,87 @@ g_controller_init (GController *self)
{
}
-static GControllerReference *
-g_controller_create_reference_internal (GController *controller,
- GControllerAction action,
- GType index_type,
- GValueArray *indices)
+static GControllerEvent *
+g_controller_create_event_internal (GController *controller,
+ GControllerAction action,
+ GType index_type,
+ GValueArray *indices)
{
- return G_CONTROLLER_GET_CLASS (controller)->create_reference (controller,
- action,
- index_type,
- indices);
+ return G_CONTROLLER_GET_CLASS (controller)->create_event (controller,
+ action,
+ index_type,
+ indices);
}
/**
- * g_controller_create_referencev
+ * g_controller_create_eventv
* @controller: a #GController
- * @action: the action for the reference
+ * @action: the action for the event
* @index_type: the type of the indices
* @indices: (allow-none): a #GValueArray containing the indices
*
- * Creates a new #GControllerReference for the given indices
+ * Creates a new #GControllerEvent for the given indices.
+ *
+ * This function should only be used by implementations of the
+ * #GController API.
*
- * The passed @indices array is copied inside the #GControllerReference
+ * The passed @indices array is copied inside the #GControllerEvent
* and can be safely freed afterwards.
*
- * If @indices is %NULL a new empty reference will be created; it is
- * possible to add indexes to it by using g_controller_reference_add_index()
- * or g_controller_reference_add_index_value().
+ * If @indices is %NULL a new empty event will be created; it is
+ * possible to add indexes to it by using g_controller_event_add_index()
+ * or g_controller_event_add_index_value().
*
- * This is a vector-based variant of g_controller_create_reference()
+ * This is a vector-based variant of g_controller_create_event(), for
+ * the convenience of language bindings.
*
- * Return value: (transfer full): a newly created #GControllerReference
- * instance. Use g_object_unref() when done using the returned object
+ * Return value: (transfer full): a newly created #GControllerEvent
+ * instance. Use g_object_unref() when done using the returned
+ * object
*/
-GControllerReference *
-g_controller_create_referencev (GController *controller,
- GControllerAction action,
- GType index_type,
- GValueArray *indices)
+GControllerEvent *
+g_controller_create_eventv (GController *controller,
+ GControllerAction action,
+ GType index_type,
+ GValueArray *indices)
{
g_return_val_if_fail (G_IS_CONTROLLER (controller), NULL);
g_return_val_if_fail (index_type != G_TYPE_INVALID, NULL);
- return g_controller_create_reference_internal (controller, action, index_type, indices);
+ return g_controller_create_event_internal (controller, action,
+ index_type,
+ indices);
}
/**
- * g_controller_create_reference:
+ * g_controller_create_event:
* @controller: a #GController
- * @action: the action for the reference
+ * @action: the action for the event
* @index_type: the type of the indices
- * @n_indices: the number of indices, or 0 to create an empty reference
- * @Varargs: the indices
+ * @n_indices: the number of indices, or 0 to create an empty event and
+ * use the #GControllerEvent API to fill it
+ * @...: the indices
+ *
+ * Creates a new #GControllerEvent for the given indices.
*
- * Creates a new #GControllerReference for the given indices
+ * This function should only be used by implementations of the
+ * #GController API.
*
- * This is a variadic arguments version of g_controller_create_referencev(),
- * for the convenience of users of the C API
+ * This is a variadic arguments version of g_controller_create_eventv(),
+ * for the convenience of users of the C API.
*
- * Return value: (transfer full): a newly created #GControllerReference
- * instance. Use g_object_unref() when done using the returned object
+ * Return value: (transfer full): a newly created #GControllerEvent
+ * instance. Use g_object_unref() when done using the returned
+ * object
*/
-GControllerReference *
-g_controller_create_reference (GController *controller,
- GControllerAction action,
- GType index_type,
- gint n_indices,
- ...)
+GControllerEvent *
+g_controller_create_event (GController *controller,
+ GControllerAction action,
+ GType index_type,
+ gint n_indices,
+ ...)
{
- GControllerReference *ref;
+ GControllerEvent *ref;
GValueArray *indices;
va_list args;
gint i;
@@ -171,8 +182,9 @@ g_controller_create_reference (GController *controller,
g_return_val_if_fail (G_IS_CONTROLLER (controller), NULL);
g_return_val_if_fail (index_type != G_TYPE_INVALID, NULL);
+ /* short-circuit the empty event case */
if (n_indices == 0)
- return g_controller_create_reference_internal (controller, action, index_type, NULL);
+ return g_controller_create_event_internal (controller, action, index_type, NULL);
indices = g_value_array_new (n_indices);
@@ -180,17 +192,13 @@ g_controller_create_reference (GController *controller,
for (i = 0; i < n_indices; i++)
{
- GValue idx = { 0, };
gchar *error;
-#if GLIB_CHECK_VERSION (2, 24, 0)
- G_VALUE_COLLECT_INIT (&idx, index_type,
+ g_value_array_insert (indices, i, NULL);
+
+ G_VALUE_COLLECT_INIT (&(indices->values[i]), index_type,
args, 0,
&error);
-#else
- g_value_init (&idx, index_type);
- G_VALUE_COLLECT (&idx, args, 0, &error);
-#endif /* GLIB_CHECK_VERSION */
if (error != NULL)
{
@@ -198,18 +206,13 @@ g_controller_create_reference (GController *controller,
g_free (error);
break;
}
-
- /* XXX - there should really be an insert_nocopy() variant */
- g_value_array_insert (indices, i, &idx);
- g_value_unset (&idx);
}
va_end (args);
- ref = g_controller_create_reference_internal (controller,
- action,
- index_type,
- indices);
+ ref = g_controller_create_event_internal (controller, action,
+ index_type,
+ indices);
g_value_array_free (indices);
@@ -219,19 +222,19 @@ g_controller_create_reference (GController *controller,
/**
* g_controller_emit_changed:
* @controller: a #GController
- * @reference: the reference to the changed data
+ * @event: the reference to the changed data
*
* Emits the #GController::changed signal with the given
* parameters
*/
void
-g_controller_emit_changed (GController *controller,
- GControllerReference *reference)
+g_controller_emit_changed (GController *controller,
+ GControllerEvent *event)
{
g_return_if_fail (G_IS_CONTROLLER (controller));
- g_return_if_fail (G_IS_CONTROLLER_REFERENCE (reference));
+ g_return_if_fail (G_IS_CONTROLLER_EVENT (event));
g_signal_emit (controller, controller_signals[CHANGED], 0,
- g_controller_reference_get_action (reference),
- reference);
+ g_controller_event_get_action (event),
+ event);
}
diff --git a/glib-controller/gcontroller.h b/glib-controller/gcontroller.h
index 6a7cdf9..54f7e09 100644
--- a/glib-controller/gcontroller.h
+++ b/glib-controller/gcontroller.h
@@ -23,8 +23,8 @@ struct _GController
/**
* GControllerClass:
- * @create_reference: virtual function; sub-classes should create a new
- * #GControllerReference instance for the given indexes
+ * @create_event: virtual function; sub-classes should create a new
+ * #GControllerEvent instance for the given indexes
* @changed: class handler for the #GController::changed signal
*
* The <structname>GControllerClass</structname> structure contains only
@@ -38,43 +38,36 @@ struct _GControllerClass
/*< public >*/
/* virtual functions */
- GControllerReference *(* create_reference) (GController *controller,
- GControllerAction action,
- GType index_type,
- GValueArray *indexes);
+ GControllerEvent * (* create_event) (GController *controller,
+ GControllerAction action,
+ GType index_type,
+ GValueArray *indexes);
/* signals */
- void (* changed) (GController *controller,
- GControllerAction action,
- GControllerReference *reference);
+ void (* changed) (GController *controller,
+ GControllerAction action,
+ GControllerEvent *event);
/*< private >*/
/* padding, for future expansion */
- void (*_g_controller0) (void);
- void (*_g_controller1) (void);
- void (*_g_controller2) (void);
- void (*_g_controller3) (void);
- void (*_g_controller4) (void);
- void (*_g_controller5) (void);
- void (*_g_controller6) (void);
- void (*_g_controller7) (void);
+ gpointer _g_controller_padding[16];
};
GType g_controller_get_type (void) G_GNUC_CONST;
-GControllerReference *g_controller_create_reference (GController *controller,
- GControllerAction action,
- GType index_type,
- gint n_indices,
- ...);
-GControllerReference *g_controller_create_referencev (GController *controller,
- GControllerAction action,
- GType index_type,
- GValueArray *indices);
-
-void g_controller_emit_changed (GController *controller,
- GControllerReference *reference);
+GControllerEvent * g_controller_create_event (GController *controller,
+ GControllerAction action,
+ GType index_type,
+ gint n_indices,
+ ...);
+GControllerEvent * g_controller_create_eventv (GController *controller,
+ GControllerAction action,
+ GType index_type,
+ GValueArray *indices);
+
+void g_controller_emit_changed (GController *controller,
+ GControllerEvent *event);
G_END_DECLS
diff --git a/glib-controller/gcontrollerevent.c b/glib-controller/gcontrollerevent.c
new file mode 100644
index 0000000..1b2f9df
--- /dev/null
+++ b/glib-controller/gcontrollerevent.c
@@ -0,0 +1,577 @@
+/**
+ * SECTION:gcontrollerevent
+ * @Title: GControllerEvent
+ * @Short_Description: A event to a storage change
+ *
+ * The #GControllerEvent is an object created by a #GController whenever
+ * a controlled data storage changes. The #GControllerEvent stores the
+ * the location of the changed data in a way that allows a View to query the
+ * storage for the actual data.
+ *
+ * A #GControllerEvent can only be created by a #GController using
+ * g_controller_create_event() and should be passed to the
+ * #GController::changed signal emitter, g_controller_emit_changed()
+ */
+
+#include "config.h"
+
+#include "gcontrollerevent.h"
+#include "gcontroller.h"
+#include "gcontrollerenumtypes.h"
+#include "gcontrollertypes.h"
+
+#include <string.h>
+#include <gobject/gvaluecollector.h>
+
+struct _GControllerEventPrivate
+{
+ GController *controller;
+
+ GControllerAction action;
+
+ GType index_type;
+ GValueArray *indices;
+};
+
+enum
+{
+ PROP_0,
+
+ PROP_CONTROLLER,
+ PROP_ACTION,
+ PROP_INDEX_TYPE,
+ PROP_INDICES
+};
+
+G_DEFINE_TYPE (GControllerEvent,
+ g_controller_event,
+ G_TYPE_OBJECT);
+
+static GValueArray *
+add_indices (GValueArray *cur_indices,
+ GValueArray *new_indices)
+{
+ gint i;
+
+ if (new_indices == NULL)
+ return cur_indices;
+
+ if (cur_indices == NULL)
+ cur_indices = g_value_array_new (new_indices->n_values);
+
+ for (i = 0; i < new_indices->n_values; i++)
+ g_value_array_append (cur_indices, g_value_array_get_nth (new_indices, i));
+
+ return cur_indices;
+}
+
+static void
+g_controller_event_constructed (GObject *gobject)
+{
+ GControllerEventPrivate *priv = G_CONTROLLER_EVENT (gobject)->priv;
+
+ g_assert (G_IS_CONTROLLER (priv->controller));
+
+ if (priv->action == G_CONTROLLER_INVALID_ACTION)
+ {
+ g_critical ("The constructed event for the GController "
+ "of type '%s' does not have a valid action.",
+ G_OBJECT_TYPE_NAME (priv->controller));
+ }
+
+ if (priv->index_type == G_TYPE_INVALID)
+ {
+ g_critical ("The constructed event for the GController "
+ "of type '%s' does not have a valid index type.",
+ G_OBJECT_TYPE_NAME (priv->controller));
+ }
+}
+
+static void
+g_controller_event_set_property (GObject *gobject,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GControllerEventPrivate *priv = G_CONTROLLER_EVENT (gobject)->priv;
+
+ switch (prop_id)
+ {
+ case PROP_CONTROLLER:
+ priv->controller = g_object_ref (g_value_get_object (value));
+ break;
+
+ case PROP_ACTION:
+ priv->action = g_value_get_enum (value);
+ break;
+
+ case PROP_INDEX_TYPE:
+ priv->index_type = g_value_get_gtype (value);
+ break;
+
+ case PROP_INDICES:
+ priv->indices = add_indices (priv->indices, g_value_get_boxed (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+g_controller_event_get_property (GObject *gobject,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GControllerEventPrivate *priv = G_CONTROLLER_EVENT (gobject)->priv;
+
+ switch (prop_id)
+ {
+ case PROP_CONTROLLER:
+ g_value_set_object (value, priv->controller);
+ break;
+
+ case PROP_ACTION:
+ g_value_set_enum (value, priv->action);
+ break;
+
+ case PROP_INDEX_TYPE:
+ g_value_set_gtype (value, priv->index_type);
+ break;
+
+ case PROP_INDICES:
+ g_value_set_boxed (value, priv->indices);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+g_controller_event_dispose (GObject *gobject)
+{
+ GControllerEventPrivate *priv = G_CONTROLLER_EVENT (gobject)->priv;
+
+ if (priv->controller != NULL)
+ {
+ g_object_unref (priv->controller);
+ priv->controller = NULL;
+ }
+
+ G_OBJECT_CLASS (g_controller_event_parent_class)->finalize (gobject);
+}
+
+static void
+g_controller_event_finalize (GObject *gobject)
+{
+ GControllerEventPrivate *priv = G_CONTROLLER_EVENT (gobject)->priv;
+
+ if (priv->indices != NULL)
+ g_value_array_free (priv->indices);
+
+ G_OBJECT_CLASS (g_controller_event_parent_class)->finalize (gobject);
+}
+
+static void
+g_controller_event_class_init (GControllerEventClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GParamSpec *pspec;
+
+ g_type_class_add_private (klass, sizeof (GControllerEventPrivate));
+
+ gobject_class->constructed = g_controller_event_constructed;
+ gobject_class->set_property = g_controller_event_set_property;
+ gobject_class->get_property = g_controller_event_get_property;
+ gobject_class->dispose = g_controller_event_dispose;
+ gobject_class->finalize = g_controller_event_finalize;
+
+ /**
+ * GControllerEvent:controller:
+ *
+ * The #GController instance that created this event
+ */
+ pspec = g_param_spec_object ("controller",
+ "Controller",
+ "The controller instance that created the event",
+ G_TYPE_CONTROLLER,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS);
+ g_object_class_install_property (gobject_class, PROP_CONTROLLER, pspec);
+
+ /**
+ * GControllerEvent:action:
+ *
+ * The #GControllerAction that caused the creation of the event
+ */
+ pspec = g_param_spec_enum ("action",
+ "Action",
+ "The action that caused the creation of the event",
+ G_TYPE_CONTROLLER_ACTION,
+ G_CONTROLLER_INVALID_ACTION,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS);
+ g_object_class_install_property (gobject_class, PROP_ACTION, pspec);
+
+ /**
+ * GControllerEvent:index-type:
+ *
+ * The #GType representation of an index stored by the event
+ */
+ pspec = g_param_spec_gtype ("index-type",
+ "Index Type",
+ "The type of the indices",
+ G_TYPE_NONE,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS);
+ g_object_class_install_property (gobject_class, PROP_INDEX_TYPE, pspec);
+
+ /**
+ * GControllerEvent:indices:
+ *
+ * A #GValueArray containing all the indices stored by the event
+ *
+ * The indices are meaningful only for the data storage controlled
+ * by the #GController that created this event
+ */
+ pspec = g_param_spec_boxed ("indices",
+ "Indices",
+ "The indices inside the data storage",
+ G_TYPE_VALUE_ARRAY,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS);
+ g_object_class_install_property (gobject_class, PROP_INDICES, pspec);
+}
+
+static void
+g_controller_event_init (GControllerEvent *self)
+{
+ self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+ G_TYPE_CONTROLLER_EVENT,
+ GControllerEventPrivate);
+
+ self->priv->controller = NULL;
+
+ self->priv->action = G_CONTROLLER_INVALID_ACTION;
+
+ self->priv->index_type = G_TYPE_INVALID;
+ self->priv->indices = NULL;
+}
+
+/**
+ * g_controller_event_get_n_indices:
+ * @event: a #GControllerEvent
+ *
+ * Retrieves the number of indices stored by the @event
+ *
+ * Return value: the number of indices
+ */
+gint
+g_controller_event_get_n_indices (GControllerEvent *event)
+{
+ g_return_val_if_fail (G_IS_CONTROLLER_EVENT (event), 0);
+
+ if (event->priv->indices == NULL)
+ return 0;
+
+ return event->priv->indices->n_values;
+}
+
+/**
+ * g_controller_event_get_index_type:
+ * @event: a #GControllerEvent
+ *
+ * Retrieves the type of the indices stored by the @event
+ *
+ * Return value: a #GType
+ */
+GType
+g_controller_event_get_index_type (GControllerEvent *event)
+{
+ g_return_val_if_fail (G_IS_CONTROLLER_EVENT (event), G_TYPE_INVALID);
+
+ return event->priv->index_type;
+}
+
+/**
+ * g_controller_event_get_controller:
+ * @event: a #GControllerEvent
+ *
+ * Retrieves a pointer to the #GController that created this event
+ *
+ * Return value: (transfer none): a pointer to a #GController
+ */
+GController *
+g_controller_event_get_controller (GControllerEvent *event)
+{
+ g_return_val_if_fail (G_IS_CONTROLLER_EVENT (event), NULL);
+
+ return event->priv->controller;
+}
+
+/**
+ * g_controller_event_get_action:
+ * @event: a #GControllerEvent
+ *
+ * Retrieves the action that caused the creation of this event
+ *
+ * Return value: a #GControllerAction
+ */
+GControllerAction
+g_controller_event_get_action (GControllerEvent *event)
+{
+ g_return_val_if_fail (G_IS_CONTROLLER_EVENT (event), G_CONTROLLER_INVALID_ACTION);
+
+ return event->priv->action;
+}
+
+/**
+ * g_controller_event_add_index_value:
+ * @event: a #GControllerEvent
+ * @value: a #GValue containing an index
+ *
+ * Adds an index stored inside a #GValue.
+ *
+ * The #GValue must contain a value with the same type as the
+ * #GControllerEvent:index-type
+ *
+ * This function is mostly useful for bindings
+ */
+void
+g_controller_event_add_index_value (GControllerEvent *event,
+ const GValue *value)
+{
+ g_return_if_fail (G_IS_CONTROLLER_EVENT (event));
+ g_return_if_fail (G_VALUE_TYPE (value) == event->priv->index_type);
+
+ if (event->priv->indices == NULL)
+ event->priv->indices = g_value_array_new (0);
+
+ g_value_array_append (event->priv->indices, value);
+}
+
+/**
+ * g_controller_event_get_index_value:
+ * @event: a #GControllerEvent
+ * @index_: the position of the index, between 0 and the number of
+ * indices stored by @event
+ * @value: an uninitialized #GValue
+ *
+ * Retrieves the index at @index_ and stores it inside @value
+ *
+ * Return value: %TRUE on success
+ */
+gboolean
+g_controller_event_get_index_value (GControllerEvent *event,
+ gint index_,
+ GValue *value)
+{
+ g_return_val_if_fail (G_IS_CONTROLLER_EVENT (event), FALSE);
+ g_return_val_if_fail (value != NULL, FALSE);
+
+ if (event->priv->indices == NULL)
+ return FALSE;
+
+ if (index_ < 0 || index_ >= event->priv->indices->n_values)
+ return FALSE;
+
+ g_value_init (value, event->priv->index_type);
+ g_value_copy (g_value_array_get_nth (event->priv->indices, index_), value);
+
+ return TRUE;
+}
+
+/**
+ * g_controller_event_add_index:
+ * @event: a #GControllerEvent
+ * @...: the index to add
+ *
+ * Variadic arguments version of g_controller_event_add_index_value(),
+ * for the convenience of users of the C API
+ */
+void
+g_controller_event_add_index (GControllerEvent *event,
+ ...)
+{
+ GValue value = { 0, };
+ gchar *error = NULL;
+ va_list args;
+
+ g_return_if_fail (G_IS_CONTROLLER_EVENT (event));
+
+ va_start (args, event);
+
+ if (event->priv->indices == NULL)
+ event->priv->indices = g_value_array_new (1);
+
+ G_VALUE_COLLECT_INIT (&value, event->priv->index_type, args, 0, &error);
+
+ if (error != NULL)
+ {
+ g_warning ("%s: %s", G_STRLOC, error);
+ g_free (error);
+ goto out;
+ }
+
+ event->priv->indices = g_value_array_append (event->priv->indices, &value);
+ g_value_unset (&value);
+
+out:
+ va_end (args);
+}
+
+/**
+ * g_controller_event_get_index:
+ * @event: a #GControllerEvent
+ * @index_: the position of the index
+ * @...: return location for the index value at the given index_ition
+ *
+ * Retrieves the index inside the @event
+ *
+ * Return value: %TRUE on success
+ */
+gboolean
+g_controller_event_get_index (GControllerEvent *event,
+ gint index_,
+ ...)
+{
+ GValue *value;
+ gchar *error = NULL;
+ va_list args;
+ gboolean res = FALSE;
+
+ g_return_val_if_fail (G_IS_CONTROLLER_EVENT (event), FALSE);
+
+ if (event->priv->indices == NULL)
+ return FALSE;
+
+ va_start (args, index_);
+
+ value = g_value_array_get_nth (event->priv->indices, index_);
+ if (value == NULL)
+ goto out;
+
+ G_VALUE_LCOPY (value, args, 0, &error);
+
+ if (error != NULL)
+ {
+ g_warning ("%s: %s", G_STRLOC, error);
+ g_free (error);
+ res = FALSE;
+ }
+ else
+ res = TRUE;
+
+out:
+ va_end (args);
+
+ return res;
+}
+
+/**
+ * g_controller_event_get_index_int:
+ * @event: a #GControllerEvent
+ * @index_: the position of the index
+ *
+ * Typed accessor for integer indexes stored inside the @event
+ *
+ * Return value: an integer index at the given index_ition
+ */
+gint
+g_controller_event_get_index_int (GControllerEvent *event,
+ gint index_)
+{
+ g_return_val_if_fail (G_IS_CONTROLLER_EVENT (event), 0);
+ g_return_val_if_fail (event->priv->index_type == G_TYPE_INT, 0);
+
+ if (event->priv->indices == NULL)
+ return 0;
+
+ if (index_ < 0 || index_ >= event->priv->indices->n_values)
+ return 0;
+
+ return g_value_get_int (g_value_array_get_nth (event->priv->indices, index_));
+}
+
+/**
+ * g_controller_event_get_index_uint:
+ * @event: a #GControllerEvent
+ * @index_: the position of the index
+ *
+ * Typed accessor for unsigned integer indexes stored inside the @event
+ *
+ * Return value: an unsigned integer index at the given index_ition
+ */
+guint
+g_controller_event_get_index_uint (GControllerEvent *event,
+ gint index_)
+{
+ g_return_val_if_fail (G_IS_CONTROLLER_EVENT (event), 0);
+ g_return_val_if_fail (event->priv->index_type == G_TYPE_UINT, 0);
+
+ if (event->priv->indices == NULL)
+ return 0;
+
+ if (index_ < 0 || index_ >= event->priv->indices->n_values)
+ return 0;
+
+ return g_value_get_uint (g_value_array_get_nth (event->priv->indices, index_));
+}
+
+/**
+ * g_controller_event_get_index_string:
+ * @event: a #GControllerEvent
+ * @index_: the position of the index
+ *
+ * Typed accessor for string indexes stored inside the @event
+ *
+ * Return value: a string index at the given index_ition
+ */
+const gchar *
+g_controller_event_get_index_string (GControllerEvent *event,
+ gint index_)
+{
+ g_return_val_if_fail (G_IS_CONTROLLER_EVENT (event), NULL);
+ g_return_val_if_fail (event->priv->index_type == G_TYPE_STRING, NULL);
+
+ if (event->priv->indices == NULL)
+ return 0;
+
+ if (index_ < 0 || index_ >= event->priv->indices->n_values)
+ return 0;
+
+ return g_value_get_string (g_value_array_get_nth (event->priv->indices, index_));
+}
+
+/**
+ * g_controller_event_get_index_pointer:
+ * @event: a #GControllerEvent
+ * @index_: the position of the index
+ *
+ * Typed accessor for pointer indexes stored inside the @event
+ *
+ * Return value: (transfer none): a pointer index at the given index_ition
+ */
+gpointer
+g_controller_event_get_index_pointer (GControllerEvent *event,
+ gint index_)
+{
+ g_return_val_if_fail (G_IS_CONTROLLER_EVENT (event), NULL);
+ g_return_val_if_fail (event->priv->index_type == G_TYPE_POINTER, NULL);
+
+ if (event->priv->indices == NULL)
+ return 0;
+
+ if (index_ < 0 || index_ >= event->priv->indices->n_values)
+ return 0;
+
+ return g_value_get_pointer (g_value_array_get_nth (event->priv->indices, index_));
+}
diff --git a/glib-controller/gcontrollerevent.h b/glib-controller/gcontrollerevent.h
new file mode 100644
index 0000000..d9c6690
--- /dev/null
+++ b/glib-controller/gcontrollerevent.h
@@ -0,0 +1,80 @@
+#if !defined(__GLIB_CONTROLLER_H_INSIDE__) && !defined(GLIB_CONTROLLER_COMPILATION)
+#error "Only <glib-controller/glib-controller.h> can be included directly."
+#endif
+
+#ifndef __G_CONTROLLER_EVENT_H__
+#define __G_CONTROLLER_EVENT_H__
+
+#include <glib-controller/gcontrollertypes.h>
+
+G_BEGIN_DECLS
+
+#define G_CONTROLLER_EVENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), G_TYPE_CONTROLLER_EVENT, GControllerEventClass))
+#define G_IS_CONTROLLER_EVENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), G_TYPE_CONTROLLER_EVENT))
+#define G_CONTROLLER_EVENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), G_TYPE_CONTROLLER_EVENT, GControllerEventClass))
+
+typedef struct _GControllerEventPrivate GControllerEventPrivate;
+typedef struct _GControllerEventClass GControllerEventClass;
+
+struct _GControllerEvent
+{
+ /*< private >*/
+ GObject parent_instance;
+
+ GControllerEventPrivate *priv;
+};
+
+/**
+ * GControllerEventClass:
+ *
+ * The <structname>GControllerEventClass</structname> structure
+ * contains only private data
+ */
+struct _GControllerEventClass
+{
+ /*< private >*/
+ GObjectClass parent_class;
+
+ /* padding */
+ void (*_g_controller_event0) (void);
+ void (*_g_controller_event1) (void);
+ void (*_g_controller_event2) (void);
+ void (*_g_controller_event3) (void);
+ void (*_g_controller_event4) (void);
+ void (*_g_controller_event5) (void);
+ void (*_g_controller_event6) (void);
+ void (*_g_controller_event7) (void);
+ void (*_g_controller_event8) (void);
+};
+
+GType g_controller_event_get_type (void) G_GNUC_CONST;
+
+GController * g_controller_event_get_controller (GControllerEvent *event);
+GControllerAction g_controller_event_get_action (GControllerEvent *event);
+gint g_controller_event_get_n_indices (GControllerEvent *event);
+GType g_controller_event_get_index_type (GControllerEvent *event);
+
+void g_controller_event_add_index_value (GControllerEvent *event,
+ const GValue *value);
+gboolean g_controller_event_get_index_value (GControllerEvent *event,
+ gint index_,
+ GValue *value);
+
+void g_controller_event_add_index (GControllerEvent *event,
+ ...);
+gboolean g_controller_event_get_index (GControllerEvent *event,
+ gint index_,
+ ...);
+
+gint g_controller_event_get_index_int (GControllerEvent *event,
+ gint index_);
+guint g_controller_event_get_index_uint (GControllerEvent *event,
+ gint index_);
+const gchar * g_controller_event_get_index_string (GControllerEvent *event,
+ gint index_);
+gpointer g_controller_event_get_index_pointer (GControllerEvent *event,
+ gint index_);
+
+G_END_DECLS
+
+#endif /* __G_CONTROLLER_EVENT_H__ */
diff --git a/glib-controller/gcontrollertypes.h b/glib-controller/gcontrollertypes.h
index 109c5fe..eaabc64 100644
--- a/glib-controller/gcontrollertypes.h
+++ b/glib-controller/gcontrollertypes.h
@@ -21,17 +21,17 @@ G_BEGIN_DECLS
*/
typedef struct _GController GController;
-#define G_TYPE_CONTROLLER_REFERENCE (g_controller_reference_get_type ())
-#define G_CONTROLLER_REFERENCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_CONTROLLER_REFERENCE, GControllerReference))
-#define G_IS_CONTROLLER_REFERENCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_CONTROLLER_REFERENCE))
+#define G_TYPE_CONTROLLER_EVENT (g_controller_event_get_type ())
+#define G_CONTROLLER_EVENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_CONTROLLER_EVENT, GControllerEvent))
+#define G_IS_CONTROLLER_EVENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_CONTROLLER_EVENT))
/**
- * GControllerReference:
+ * GControllerEvent:
*
- * The <structname>GControllerReference</structname> structure contains
+ * The <structname>GControllerEvent</structname> structure contains
* only private data and should be accessed using the provided API
*/
-typedef struct _GControllerReference GControllerReference;
+typedef struct _GControllerEvent GControllerEvent;
#define G_TYPE_ARRAY_CONTROLLER (g_array_controller_get_type ())
#define G_ARRAY_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_ARRAY_CONTROLLER, GArrayController))
diff --git a/glib-controller/glib-controller.h b/glib-controller/glib-controller.h
index 566277e..9eba4b1 100644
--- a/glib-controller/glib-controller.h
+++ b/glib-controller/glib-controller.h
@@ -4,7 +4,7 @@
#define __GLIB_CONTROLLER_H_INSIDE__
#include "gcontrollertypes.h"
-#include "gcontrollerreference.h"
+#include "gcontrollerevent.h"
#include "gcontroller.h"
#include "garraycontroller.h"
diff --git a/glib-controller/tests/array-controller.c b/glib-controller/tests/array-controller.c
index 8abaf76..6161ac0 100644
--- a/glib-controller/tests/array-controller.c
+++ b/glib-controller/tests/array-controller.c
@@ -18,22 +18,22 @@ array_constructor (void)
}
static void
-array_create_reference (void)
+array_create_event (void)
{
GController *controller;
- GControllerReference *reference;
+ GControllerEvent *event;
controller = g_array_controller_new (NULL);
- reference = g_controller_create_reference (controller, G_CONTROLLER_CLEAR,
+ event = g_controller_create_event (controller, G_CONTROLLER_CLEAR,
G_TYPE_UINT, 1,
0);
- g_assert (G_IS_CONTROLLER_REFERENCE (reference));
- g_assert (g_controller_reference_get_index_type (reference) == G_TYPE_UINT);
- g_assert_cmpint (g_controller_reference_get_n_indices (reference), ==, 1);
- g_assert_cmpint (g_controller_reference_get_index_uint (reference, 0), ==, 0);
+ g_assert (G_IS_CONTROLLER_EVENT (event));
+ g_assert (g_controller_event_get_index_type (event) == G_TYPE_UINT);
+ g_assert_cmpint (g_controller_event_get_n_indices (event), ==, 1);
+ g_assert_cmpint (g_controller_event_get_index_uint (event, 0), ==, 0);
- g_object_unref (reference);
+ g_object_unref (event);
g_object_unref (controller);
}
@@ -47,15 +47,15 @@ typedef struct _ChangedClosure {
static void
on_changed (GController *controller,
GControllerAction action,
- GControllerReference *reference,
+ GControllerEvent *event,
gpointer user_data)
{
ChangedClosure *clos = user_data;
gint i, n_indices;
GType index_type;
- index_type = g_controller_reference_get_index_type (reference);
- n_indices = g_controller_reference_get_n_indices (reference);
+ index_type = g_controller_event_get_index_type (event);
+ n_indices = g_controller_event_get_n_indices (event);
g_assert_cmpint (action, ==, clos->action);
g_assert (index_type == clos->index_type);
@@ -63,7 +63,7 @@ on_changed (GController *controller,
for (i = 0; i < n_indices; i++)
{
- guint idx = g_controller_reference_get_index_uint (reference, i);
+ guint idx = g_controller_event_get_index_uint (event, i);
g_assert_cmpint (idx, ==, clos->indices[i]);
}
}
@@ -74,7 +74,7 @@ array_emit_changed (void)
GArray *array = g_array_new (FALSE, FALSE, sizeof (int));
GController *controller = g_array_controller_new (array);
ChangedClosure expected = { 0, 0 };
- GControllerReference *ref;
+ GControllerEvent *ref;
gulong id;
int value;
@@ -89,8 +89,8 @@ array_emit_changed (void)
value = 42;
g_array_append_val (array, value);
- ref = g_controller_create_reference (controller, G_CONTROLLER_ADD, G_TYPE_UINT, 1, 0);
- g_assert (G_IS_CONTROLLER_REFERENCE (ref));
+ ref = g_controller_create_event (controller, G_CONTROLLER_ADD, G_TYPE_UINT, 1, 0);
+ g_assert (G_IS_CONTROLLER_EVENT (ref));
g_controller_emit_changed (controller, ref);
g_object_unref (ref);
@@ -108,14 +108,14 @@ array_bulk_emit_changed (void)
GArray *array = g_array_new (FALSE, FALSE, sizeof (int));
GController *controller = g_array_controller_new (array);
ChangedClosure expected = { 0, 0 };
- GControllerReference *ref;
+ GControllerEvent *ref;
gulong id;
int i;
id = g_signal_connect (controller, "changed", G_CALLBACK (on_changed), &expected);
- ref = g_controller_create_reference (controller, G_CONTROLLER_ADD, G_TYPE_UINT, 0);
- g_assert (G_IS_CONTROLLER_REFERENCE (ref));
+ ref = g_controller_create_event (controller, G_CONTROLLER_ADD, G_TYPE_UINT, 0);
+ g_assert (G_IS_CONTROLLER_EVENT (ref));
expected.action = G_CONTROLLER_ADD;
expected.index_type = G_TYPE_UINT;
@@ -129,7 +129,7 @@ array_bulk_emit_changed (void)
g_array_append_val (array, val);
expected.indices[i] = i;
- g_controller_reference_add_index (ref, i);
+ g_controller_event_add_index (ref, i);
}
g_controller_emit_changed (controller, ref);
@@ -150,7 +150,7 @@ main (int argc, char *argv[])
g_test_init (&argc, &argv, NULL);
g_test_add_func ("/array/constructor", array_constructor);
- g_test_add_func ("/array/create-reference", array_create_reference);
+ g_test_add_func ("/array/create-event", array_create_event);
g_test_add_func ("/array/emit-changed", array_emit_changed);
g_test_add_func ("/array/emit-bulk-changed", array_bulk_emit_changed);
diff --git a/glib-controller/tests/hash-controller.c b/glib-controller/tests/hash-controller.c
index 670a1df..a8615a4 100644
--- a/glib-controller/tests/hash-controller.c
+++ b/glib-controller/tests/hash-controller.c
@@ -18,20 +18,20 @@ hash_constructor (void)
}
static void
-hash_create_reference (void)
+hash_create_event (void)
{
GController *controller;
- GControllerReference *reference;
+ GControllerEvent *event;
controller = g_hash_controller_new (NULL);
- reference = g_controller_create_reference (controller, G_CONTROLLER_CLEAR, G_TYPE_POINTER, 1, GINT_TO_POINTER (0xdeadbeef));
+ event = g_controller_create_event (controller, G_CONTROLLER_CLEAR, G_TYPE_POINTER, 1, GINT_TO_POINTER (0xdeadbeef));
- g_assert (G_IS_CONTROLLER_REFERENCE (reference));
- g_assert (g_controller_reference_get_index_type (reference) == G_TYPE_POINTER);
- g_assert_cmpint (g_controller_reference_get_n_indices (reference), ==, 1);
- g_assert (g_controller_reference_get_index_pointer (reference, 0) == GINT_TO_POINTER (0xdeadbeef));
+ g_assert (G_IS_CONTROLLER_EVENT (event));
+ g_assert (g_controller_event_get_index_type (event) == G_TYPE_POINTER);
+ g_assert_cmpint (g_controller_event_get_n_indices (event), ==, 1);
+ g_assert (g_controller_event_get_index_pointer (event, 0) == GINT_TO_POINTER (0xdeadbeef));
- g_object_unref (reference);
+ g_object_unref (event);
g_object_unref (controller);
}
@@ -45,15 +45,15 @@ typedef struct _ChangedClosure {
static void
on_changed (GController *controller,
GControllerAction action,
- GControllerReference *reference,
+ GControllerEvent *event,
gpointer user_data)
{
ChangedClosure *clos = user_data;
gint i, n_indices;
GType index_type;
- index_type = g_controller_reference_get_index_type (reference);
- n_indices = g_controller_reference_get_n_indices (reference);
+ index_type = g_controller_event_get_index_type (event);
+ n_indices = g_controller_event_get_n_indices (event);
g_assert_cmpint (action, ==, clos->action);
g_assert (index_type == clos->index_type);
@@ -61,7 +61,7 @@ on_changed (GController *controller,
for (i = 0; i < n_indices; i++)
{
- const gchar *idx = g_controller_reference_get_index_string (reference, i);
+ const gchar *idx = g_controller_event_get_index_string (event, i);
if (g_test_verbose ())
g_print ("Got '%s' (%p), expected '%s' (%p)\n",
@@ -78,7 +78,7 @@ hash_emit_changed (void)
GHashTable *hash = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free);
GController *controller = g_hash_controller_new (hash);
ChangedClosure expected = { 0, };
- GControllerReference *ref;
+ GControllerEvent *ref;
gchar *foo;
gulong id;
@@ -94,8 +94,8 @@ hash_emit_changed (void)
g_hash_table_insert (hash, foo, g_strdup ("bar"));
- ref = g_controller_create_reference (controller, G_CONTROLLER_ADD, G_TYPE_STRING, 1, foo);
- g_assert (G_IS_CONTROLLER_REFERENCE (ref));
+ ref = g_controller_create_event (controller, G_CONTROLLER_ADD, G_TYPE_STRING, 1, foo);
+ g_assert (G_IS_CONTROLLER_EVENT (ref));
g_controller_emit_changed (controller, ref);
g_object_unref (ref);
@@ -115,7 +115,7 @@ main (int argc, char *argv[])
g_test_init (&argc, &argv, NULL);
g_test_add_func ("/hash/constructor", hash_constructor);
- g_test_add_func ("/hash/create-reference", hash_create_reference);
+ g_test_add_func ("/hash/create-event", hash_create_event);
g_test_add_func ("/hash/emit-changed", hash_emit_changed);
return g_test_run ();
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
