git.roojs.org Git - gnome.gobject-introspection/blob - tests/invoke/genericmarshaller.c

   1 /* GObject - GLib Type, Object, Parameter and Signal Library
   2  * testmarshallergeneric.c: Generic CClosure marshaller
   3  * Copyright (C) 2007 Johan Dahlin
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <string.h>
  22 #include <glib-object.h>
  23 #include "girepository.h"
  24
  25 typedef struct {
  26   GObject parent;
  27 } TestObject;
  28
  29 typedef struct {
  30   GObjectClass parent_class;
  31   void (* test1)                (TestObject *object);
  32   void (* test2)                (TestObject *object, char *str);
  33   int  (* test3)                (TestObject *object, int i);
  34   void (* test4)                (TestObject *object,
  35                                  gboolean b, long l, float f, double d,
  36                                  guint uint, gulong ulong);
  37 } TestObjectClass;
  38
  39 #define TEST_TYPE_OBJECT            (test_object_get_type())
  40 #define TEST_OBJECT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_OBJECT, TestObject))
  41 #define TEST_OBJECT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_TYPE_OBJECT, TestObjectClass))
  42 #define TEST_IS_OBJECT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_OBJECT))
  43 #define TEST_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), TEST_TYPE_OBJECT))
  44 #define TEST_OBJECT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), TEST_TYPE_OBJECT, TestObjectClass))
  45
  46 GType test_object_get_type (void);
  47
  48 enum {
  49   TEST1,
  50   TEST2,
  51   TEST3,
  52   TEST4,
  53   LAST_SIGNAL
  54 };
  55
  56 static guint object_signals[LAST_SIGNAL] = { 0 };
  57
  58 G_DEFINE_TYPE (TestObject, test_object, G_TYPE_OBJECT);
  59
  60 static void test_object_init (TestObject *self)
  61 {
  62 }
  63
  64 static void test_object_class_init (TestObjectClass *klass)
  65 {
  66   GObjectClass *gobject_class = (GObjectClass*) klass;
  67
  68   object_signals[TEST1] =
  69     g_signal_new ("test1",
  70                   G_TYPE_FROM_CLASS (gobject_class),
  71                   G_SIGNAL_RUN_FIRST,
  72                   G_STRUCT_OFFSET (TestObjectClass, test1),
  73                   NULL, NULL,
  74                   gi_cclosure_marshal_generic,
  75                   G_TYPE_NONE, 0);
  76   object_signals[TEST2] =
  77     g_signal_new ("test2",
  78                   G_TYPE_FROM_CLASS (gobject_class),
  79                   G_SIGNAL_RUN_FIRST,
  80                   G_STRUCT_OFFSET (TestObjectClass, test2),
  81                   NULL, NULL,
  82                   gi_cclosure_marshal_generic,
  83                   G_TYPE_NONE, 1,
  84                   G_TYPE_STRING);
  85   object_signals[TEST3] =
  86     g_signal_new ("test3",
  87                   G_TYPE_FROM_CLASS (gobject_class),
  88                   G_SIGNAL_RUN_LAST,
  89                   G_STRUCT_OFFSET (TestObjectClass, test3),
  90                   NULL, NULL,
  91                   gi_cclosure_marshal_generic,
  92                   G_TYPE_INT, 1,
  93                   G_TYPE_DOUBLE);
  94   object_signals[TEST4] =
  95     g_signal_new ("test4",
  96                   G_TYPE_FROM_CLASS (gobject_class),
  97                   G_SIGNAL_RUN_LAST,
  98                   G_STRUCT_OFFSET (TestObjectClass, test3),
  99                   NULL, NULL,
 100                   gi_cclosure_marshal_generic,
 101                   G_TYPE_NONE, 6,
 102                   G_TYPE_BOOLEAN,
 103                   G_TYPE_LONG,
 104                   G_TYPE_FLOAT,
 105                   G_TYPE_DOUBLE,
 106                   G_TYPE_UINT,
 107                   G_TYPE_ULONG);
 108 }
 109
 110 static void
 111 test1_callback (TestObject *object, char *data)
 112 {
 113   g_return_if_fail (TEST_IS_OBJECT (object));
 114   g_return_if_fail (!strcmp (data, "user-data"));
 115 }
 116
 117 static void
 118 test1_callback_swapped (char *data, TestObject *object)
 119 {
 120   g_return_if_fail (TEST_IS_OBJECT (object));
 121   g_return_if_fail (!strcmp (data, "user-data"));
 122 }
 123
 124 static void
 125 test2_callback (TestObject *object, char *string)
 126 {
 127   g_return_if_fail (TEST_IS_OBJECT (object));
 128   g_return_if_fail (!strcmp (string, "string"));
 129 }
 130
 131 static int
 132 test3_callback (TestObject *object, double f)
 133 {
 134   g_return_val_if_fail (TEST_IS_OBJECT (object), -1);
 135   g_return_val_if_fail (f == 42.0, -1);
 136
 137   return 20;
 138 }
 139
 140 static void
 141 test4_callback (TestObject *object,
 142                 gboolean b, long l, float f, double d, guint uint, gulong ulong,
 143                 gpointer user_data)
 144 {
 145   g_return_if_fail (b == TRUE);
 146   g_return_if_fail (l == 10L);
 147   g_return_if_fail (f <= 3.14001 && f >= 3.13999);
 148   g_return_if_fail (d == 1.78);
 149   g_return_if_fail (uint == 20);
 150   g_return_if_fail (ulong == 30L);
 151 }
 152
 153 static void
 154 test_cclosure_marshal (void)
 155 {
 156   TestObject *object;
 157   gchar *data = "user-data";
 158   int i;
 159
 160   g_type_init ();
 161
 162   object = g_object_new (TEST_TYPE_OBJECT, NULL);
 163   g_signal_connect (G_OBJECT (object),
 164                     "test1",
 165                     G_CALLBACK (test1_callback),
 166                     data);
 167   g_signal_connect_swapped (G_OBJECT (object),
 168                     "test1",
 169                     G_CALLBACK (test1_callback_swapped),
 170                     data);
 171   g_signal_connect (G_OBJECT (object),
 172                     "test2",
 173                     G_CALLBACK (test2_callback),
 174                     NULL);
 175   g_signal_connect (G_OBJECT (object),
 176                     "test3",
 177                     G_CALLBACK (test3_callback),
 178                     NULL);
 179   g_signal_connect (G_OBJECT (object),
 180                     "test4",
 181                     G_CALLBACK (test4_callback),
 182                     NULL);
 183
 184   g_signal_emit (G_OBJECT (object), object_signals[TEST1], 0);
 185   g_signal_emit (G_OBJECT (object), object_signals[TEST2], 0, "string");
 186   g_signal_emit (G_OBJECT (object), object_signals[TEST3], 0, 42.0, &i);
 187   g_signal_emit (G_OBJECT (object), object_signals[TEST4], 0,
 188                  TRUE, 10L, 3.14, 1.78, 20, 30L);
 189   g_assert (i == 20);
 190
 191   g_object_unref (object);
 192 }
 193
 194 int main(void)
 195 {
 196   test_cclosure_marshal ();
 197
 198   return 0;
 199 }
 200