Changeset 05ca0d8

Timestamp:

Jun 1, 2010, 3:30:12 AM (14 years ago)

Author:

David Benjamin <davidben@mit.edu>

Branches:

master, release-1.10, release-1.7, release-1.8, release-1.9

Children:

d2a4534

Parents:

7a6e6c7

git-author:

David Benjamin <davidben@mit.edu> (06/01/10 02:41:55)

git-committer:

David Benjamin <davidben@mit.edu> (06/01/10 03:30:12)

Message:

Implement our own owl_signal_connect_object

This is actually more code, but that's because of comments. It'll be
MUCH less error-prone.

Files:

• owl.h (modified) (1 diff)
• popwin.c (modified) (2 diffs)
• util.c (modified) (2 diffs)

owl.h

@@ -410 +410 @@
   
 typedef struct _owl_popwin {
-  gulong screen_resize_id;
   owl_window *border;
   owl_window *content;

popwin.c

@@ -12 +12 @@
   pw->content = owl_window_new(pw->border);
   g_signal_connect(pw->border, "redraw", G_CALLBACK(owl_popwin_draw_border), 0);
-  pw->screen_resize_id = g_signal_connect_object(owl_window_get_screen(), "resized", G_CALLBACK(owl_popwin_size_border), pw->border, 0);
-  g_signal_connect_object(pw->border, "resized", G_CALLBACK(owl_popwin_size_content), pw->content, 0);
+  owl_signal_connect_object(owl_window_get_screen(), "resized", G_CALLBACK(owl_popwin_size_border), pw->border, 0);
+  owl_signal_connect_object(pw->border, "resized", G_CALLBACK(owl_popwin_size_content), pw->content, 0);
 
   /* bootstrap sizing */
@@ -73 +73 @@
   g_object_unref(pw->content);
 
-  /* See comment on g_signal_connect_object; it only prevents the closure from
-   * being invoked. The signal handler itself still gets leaked. The other
-   * signal is okay, since we delete both at the same time. */
-  if (g_signal_handler_is_connected(owl_window_get_screen(), pw->screen_resize_id))
-      g_signal_handler_disconnect(owl_window_get_screen(), pw->screen_resize_id);
-
   pw->border = 0;
   pw->content = 0;

util.c

@@ -7 +7 @@
 #include <sys/stat.h>
 #include <sys/types.h>
+
+#include <glib-object.h>
 
 void sepbar(const char *in)
@@ -787 +789 @@
   return buf;
 }
+
+typedef struct { /*noproto*/
+  GObject  *sender;
+  gulong    signal_id;
+} SignalData;
+
+static void _closure_invalidated(gpointer data, GClosure *closure);
+
+/*
+ * GObject's g_signal_connect_object has a documented bug. This function is
+ * identical except it does not leak the signal handler.
+ */
+gulong owl_signal_connect_object(gpointer sender, const gchar *detailed_signal, GCallback c_handler, gpointer receiver, GConnectFlags connect_flags)
+{
+  g_return_val_if_fail (G_TYPE_CHECK_INSTANCE (sender), 0);
+  g_return_val_if_fail (detailed_signal != NULL, 0);
+  g_return_val_if_fail (c_handler != NULL, 0);
+
+  if (receiver) {
+    SignalData *sdata;
+    GClosure *closure;
+    gulong signal_id;
+
+    g_return_val_if_fail (G_IS_OBJECT (receiver), 0);
+
+    closure = ((connect_flags & G_CONNECT_SWAPPED) ? g_cclosure_new_object_swap : g_cclosure_new_object) (c_handler, receiver);
+    signal_id = g_signal_connect_closure (sender, detailed_signal, closure, connect_flags & G_CONNECT_AFTER);
+
+    /* Register the missing hooks */
+    sdata = g_slice_new0(SignalData);
+    sdata->sender = sender;
+    sdata->signal_id = signal_id;
+
+    g_closure_add_invalidate_notifier(closure, sdata, _closure_invalidated);
+
+    return signal_id;
+  } else {
+    return g_signal_connect_data(sender, detailed_signal, c_handler, NULL, NULL, connect_flags);
+  }
+}
+
+/*
+ * There are three ways the signal could come to an end:
+ * 
+ * 1. The user explicitly disconnects it with the returned signal_id.
+ *    - In that case, the disconnection unref's the closure, causing it
+ *      to first be invalidated. The handler's already disconnected, so
+ *      we have no work to do.
+ * 2. The sender gets destroyed.
+ *    - GObject will disconnect each signal which then goes into the above
+ *      case. Our handler does no work.
+ * 3. The receiver gets destroyed.
+ *    - The GClosure was created by g_cclosure_new_object_{,swap} which gets
+ *      invalidated when the receiver is destroyed. We then follow through case 1
+ *      again, but *this* time, the handler has not been disconnected. We then
+ *      clean up ourselves.
+ *
+ * We can't actually hook into this process earlier with weakrefs as GObject
+ * will, on object dispose, first disconnect signals, then invalidate closures,
+ * and notify weakrefs last.
+ */
+static void _closure_invalidated(gpointer data, GClosure *closure)
+{
+  SignalData *sdata = data;
+  if (g_signal_handler_is_connected(sdata->sender, sdata->signal_id)) {
+    g_signal_handler_disconnect(sdata->sender, sdata->signal_id);
+  }
+  g_slice_free(SignalData, sdata);
+}
+