Branch data     Line data    Source code

       1                 :            : #include <glib.h>
       2                 :            : #include <glib-object.h>
       3                 :            : 
       4                 :            : #define MY_TYPE_BADGER              (my_badger_get_type ())
       5                 :            : #define MY_BADGER(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_TYPE_BADGER, MyBadger))
       6                 :            : #define MY_IS_BADGER(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_TYPE_BADGER))
       7                 :            : #define MY_BADGER_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), MY_TYPE_BADGER, MyBadgerClass))
       8                 :            : #define MY_IS_BADGER_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), MY_TYPE_BADGER))
       9                 :            : #define MY_BADGER_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), MY_TYPE_BADGER, MyBadgerClass))
      10                 :            : 
      11                 :            : enum {
      12                 :            :   PROP_0,
      13                 :            :   PROP_MAMA
      14                 :            : };
      15                 :            : 
      16                 :            : typedef struct _MyBadger MyBadger;
      17                 :            : typedef struct _MyBadgerClass MyBadgerClass;
      18                 :            : 
      19                 :            : struct _MyBadger
      20                 :            : {
      21                 :            :   GObject parent_instance;
      22                 :            : 
      23                 :            :   MyBadger * mama;
      24                 :            :   guint mama_notify_count;
      25                 :            : };
      26                 :            : 
      27                 :            : struct _MyBadgerClass
      28                 :            : {
      29                 :            :   GObjectClass parent_class;
      30                 :            : };
      31                 :            : 
      32                 :            : static GType my_badger_get_type (void);
      33   [ +  +  +  -  :         12 : G_DEFINE_TYPE (MyBadger, my_badger, G_TYPE_OBJECT)
                   +  + ]
      34                 :            : 
      35                 :            : static void my_badger_dispose (GObject * object);
      36                 :            : 
      37                 :            : static void my_badger_get_property (GObject    *object,
      38                 :            :                                     guint       prop_id,
      39                 :            :                                     GValue     *value,
      40                 :            :                                     GParamSpec *pspec);
      41                 :            : static void my_badger_set_property (GObject      *object,
      42                 :            :                                     guint         prop_id,
      43                 :            :                                     const GValue *value,
      44                 :            :                                     GParamSpec   *pspec);
      45                 :            : 
      46                 :            : static void my_badger_mama_notify (GObject    *object,
      47                 :            :                                    GParamSpec *pspec);
      48                 :            : 
      49                 :            : static void
      50                 :          1 : my_badger_class_init (MyBadgerClass * klass)
      51                 :            : {
      52                 :            :   GObjectClass *gobject_class;
      53                 :            : 
      54                 :          1 :   gobject_class = (GObjectClass *) klass;
      55                 :            : 
      56                 :          1 :   gobject_class->dispose = my_badger_dispose;
      57                 :            : 
      58                 :          1 :   gobject_class->get_property = my_badger_get_property;
      59                 :          1 :   gobject_class->set_property = my_badger_set_property;
      60                 :            : 
      61                 :          1 :   g_object_class_install_property (gobject_class,
      62                 :            :                                    PROP_MAMA,
      63                 :            :                                    g_param_spec_object ("mama",
      64                 :            :                                                         NULL,
      65                 :            :                                                         NULL,
      66                 :            :                                                         MY_TYPE_BADGER,
      67                 :            :                                                         G_PARAM_READWRITE));
      68                 :          1 : }
      69                 :            : 
      70                 :            : static void
      71                 :          2 : my_badger_init (MyBadger * self)
      72                 :            : {
      73                 :          2 :   g_signal_connect (self, "notify::mama", G_CALLBACK (my_badger_mama_notify),
      74                 :            :       NULL);
      75                 :          2 : }
      76                 :            : 
      77                 :            : static void
      78                 :          2 : my_badger_dispose (GObject * object)
      79                 :            : {
      80                 :            :   MyBadger * self;
      81                 :            : 
      82                 :          2 :   self = MY_BADGER (object);
      83                 :            : 
      84         [ +  + ]:          2 :   if (self->mama != NULL)
      85                 :            :     {
      86                 :          1 :       g_object_unref (self->mama);
      87                 :          1 :       self->mama = NULL;
      88                 :            :     }
      89                 :            : 
      90                 :          2 :   G_OBJECT_CLASS (my_badger_parent_class)->dispose (object);
      91                 :          2 : }
      92                 :            : 
      93                 :            : static void
      94                 :          1 : my_badger_get_property (GObject    *object,
      95                 :            :                         guint        prop_id,
      96                 :            :                         GValue     *value,
      97                 :            :                         GParamSpec *pspec)
      98                 :            : {
      99                 :            :   MyBadger *self;
     100                 :            : 
     101                 :          1 :   self = MY_BADGER (object);
     102                 :            : 
     103         [ +  - ]:          1 :   switch (prop_id)
     104                 :            :     {
     105                 :          1 :     case PROP_MAMA:
     106                 :          1 :       g_value_set_object (value, self->mama);
     107                 :          1 :       break;
     108                 :          0 :     default:
     109                 :          0 :       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     110                 :          0 :       break;
     111                 :            :     }
     112                 :          1 : }
     113                 :            : 
     114                 :            : static void
     115                 :          2 : my_badger_set_property (GObject      *object,
     116                 :            :                         guint         prop_id,
     117                 :            :                         const GValue *value,
     118                 :            :                         GParamSpec   *pspec)
     119                 :            : {
     120                 :            :   MyBadger *self;
     121                 :            : 
     122                 :          2 :   self = MY_BADGER (object);
     123                 :            : 
     124         [ +  - ]:          2 :   switch (prop_id)
     125                 :            :     {
     126                 :          2 :     case PROP_MAMA:
     127         [ -  + ]:          2 :       if (self->mama)
     128                 :          0 :         g_object_unref (self->mama);
     129                 :          2 :       self->mama = g_value_dup_object (value);
     130         [ +  + ]:          2 :       if (self->mama)
     131                 :          1 :         g_object_set (self->mama, "mama", NULL, NULL); /* another notify */
     132                 :          2 :       break;
     133                 :          0 :     default:
     134                 :          0 :       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     135                 :          0 :       break;
     136                 :            :     }
     137                 :          2 : }
     138                 :            : 
     139                 :            : static void
     140                 :          2 : my_badger_mama_notify (GObject    *object,
     141                 :            :                        GParamSpec *pspec)
     142                 :            : {
     143                 :            :   MyBadger *self;
     144                 :            : 
     145                 :          2 :   self = MY_BADGER (object);
     146                 :          2 :   self->mama_notify_count++;
     147                 :          2 : }
     148                 :            : 
     149                 :            : static void
     150                 :          1 : test_refcount_properties_4 (void)
     151                 :            : {
     152                 :            :   MyBadger * badger1, * badger2;
     153                 :            :   gpointer test;
     154                 :            : 
     155                 :          1 :   badger1 = g_object_new (MY_TYPE_BADGER, NULL);
     156                 :          1 :   badger2 = g_object_new (MY_TYPE_BADGER, NULL);
     157                 :            : 
     158                 :          1 :   g_object_set (badger1, "mama", badger2, NULL);
     159                 :          1 :   g_assert_cmpuint (badger1->mama_notify_count, ==, 1);
     160                 :          1 :   g_assert_cmpuint (badger2->mama_notify_count, ==, 1);
     161                 :          1 :   g_object_get (badger1, "mama", &test, NULL);
     162                 :          1 :   g_assert_cmpmem (test, sizeof (MyBadger), badger2, sizeof (MyBadger));
     163                 :          1 :   g_object_unref (test);
     164                 :            : 
     165                 :          1 :   g_object_unref (badger1);
     166                 :          1 :   g_object_unref (badger2);
     167                 :          1 : }
     168                 :            : 
     169                 :            : int
     170                 :          1 : main (int argc, gchar *argv[])
     171                 :            : {
     172                 :          1 :   g_log_set_always_fatal (G_LOG_LEVEL_WARNING |
     173                 :          1 :                           G_LOG_LEVEL_CRITICAL |
     174                 :          1 :                           g_log_set_always_fatal (G_LOG_FATAL_MASK));
     175                 :            : 
     176                 :          1 :   g_test_init (&argc, &argv, NULL);
     177                 :            : 
     178                 :          1 :   g_test_add_func ("/gobject/refcount/properties-4", test_refcount_properties_4);
     179                 :            : 
     180                 :          1 :   return g_test_run ();
     181                 :            : }