Changeset 10985

Timestamp:

06/16/07 12:14:58 (2 years ago)

Author:

piotras

Message:

Added connect "method".
Implemented g_closure for user's callbacks

Files:

• trunk/midgard/apis/php4/midgard.c (modified) (3 diffs)
• trunk/midgard/apis/php4/php_midgard_gobject.h (modified) (1 diff)
• trunk/midgard/apis/php4/php_midgard_gobject_generic.c (modified) (1 diff)

trunk/midgard/apis/php4/midgard.c

@@ -179 +179 @@
-
-/* Midgard object methods */
-3
+4
-
-static struct 
@@ -209 +209 @@
-    {"undelete",                ZEND_FN(_php_midgard_object_undelete)                   }, 
-    {"export",                  ZEND_FN(_php_midgard_object_export)                     },
+    {"connect",                 ZEND_FN(_php_midgard_object_connect)                    },
-        { NULL, NULL } 
-};
@@ -880 +881 @@
-        }
-}
+
+PHP_FUNCTION(_php_midgard_object_connect)
+{
+        CHECK_MGD;
+        NOT_STATIC_METHOD();
+        zval *zval_object = getThis();
+
+        php_midgard_gobject_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+}
+
-
-/* End MIDGARD2 methods */

trunk/midgard/apis/php4/php_midgard_gobject.h

@@ -43 +43 @@
-zend_class_entry *php_midgard_get_baseclass_ptr(zend_class_entry *ce);
-
+/* SIGNALS */
+void php_midgard_gobject_connect(INTERNAL_FUNCTION_PARAMETERS);
+
-#endif /* PHP_MIDGARD_GOBJECT_GENERIC  */

trunk/midgard/apis/php4/php_midgard_gobject_generic.c

@@ -630 +630 @@
-        return rce;
-}
+
+/* SIGNALS */
+
+typedef struct {
+        GClosure closure;
+        zval *callback;
+        zval ***args;
+        guint argc;
+        guint type;
+        zval *zobject;
+} php_mgd_closure;
+
+static void php_midgard_closure_invalidate(gpointer data, GClosure *closure)
+{
+        php_mgd_closure *mgdclosure = (php_mgd_closure *) closure;
+        efree(mgdclosure->args);
+
+        mgdclosure->callback = NULL;
+        mgdclosure->args = NULL;
+        mgdclosure->zobject = NULL;
+}
+
+static void php_midgard_closure_marshal(GClosure *closure,
+                GValue *return_value, guint n_param_values,
+                const GValue *param_values, gpointer invocation_hint,
+                gpointer marshal_data)
+{
+        php_mgd_closure *mgdclosure = (php_mgd_closure *) closure;
+        gchar *callback_func;
+
+        /* check if method can be invoked for object */
+        if(mgdclosure->zobject != NULL) {
+
+                gchar *lname = 
+                        zend_str_tolower_dup(Z_STRVAL_P(mgdclosure->callback), 
+                                        Z_STRLEN_P(mgdclosure->callback));
+
+                if (!zend_hash_exists(&Z_OBJCE_P(mgdclosure->zobject)->function_table, 
+                                        lname, 
+                                        Z_STRLEN_P(mgdclosure->callback)+1)) {
+                        
+                        efree(lname);
+                        php_error(E_WARNING, "Can not invoke '%s::%s' as callback", 
+                                        Z_OBJCE_P(mgdclosure->zobject)->name, 
+                                        Z_STRVAL_P(mgdclosure->callback));
+                        return;
+                }
+
+                efree(lname);
+
+        } else {
+                
+                if (!zend_is_callable(mgdclosure->callback, 0, &callback_func)) {
+                        
+                        php_error(E_WARNING, "Can not invoke '%s' callback", callback_func);
+                        return;
+                }
+        }
+
+        zval *retval = NULL;
+        guint i;
+        zval ***args = mgdclosure->args;
+        guint argc = mgdclosure->argc;
+
+        if(args != NULL) {
+                
+                for(i = 0; i < argc ; i++) {                    
+                        if(*args[i] == NULL){
+                                g_warning("Value is NULL, Setting 0.");
+                                MAKE_STD_ZVAL(*args[i]);
+                                ZVAL_LONG(*args[i], 0);
+                        }
+                }
+        }
+
+        if(mgdclosure->zobject != NULL) {
+
+                call_user_function_ex(NULL, &mgdclosure->zobject , mgdclosure->callback,
+                                &retval, argc, args, 0, NULL TSRMLS_CC);
+                
+        } else {
+                
+                call_user_function_ex(EG(function_table), NULL, mgdclosure->callback,
+                                &retval, argc, args, 0, NULL TSRMLS_CC);
+        }
+
+}
+
+static GClosure *php_midgard_closure_new(zval *callback, zval *zobject, zval ***args, guint argc TSRMLS_DC)
+{
+        GClosure *closure;
+        php_mgd_closure *mgdclosure;
+
+        if(zobject == NULL) {
+                
+                closure = g_closure_new_simple(sizeof(php_mgd_closure), NULL);
+        
+        } else {
+
+                php_midgard_gobject *php_gobject =
+                        (php_midgard_gobject *)zend_object_store_get_object(zobject TSRMLS_CC);
+                
+                if(g_type_from_name(Z_OBJCE_P(zobject)->name)) {
+
+                        GObject *object = G_OBJECT(php_gobject->gobject);
+                        closure = g_closure_new_object(sizeof(php_mgd_closure), object);
+                
+                } else {
+                        
+                        closure = g_closure_new_simple(sizeof(php_mgd_closure), NULL);
+                }
+        }
+        
+        if(!closure) 
+                php_error(E_ERROR, "Couldn't create new closure");
+
+        mgdclosure = (php_mgd_closure*) closure;
+        zval_add_ref(&callback);
+        mgdclosure->callback = callback;
+        mgdclosure->zobject = zobject;
+        mgdclosure->argc = argc;
+        mgdclosure->args = NULL;
+
+        if(args != NULL) {
+
+                zval_add_ref(*args);
+                mgdclosure->args = args;                
+        }
+        
+        g_closure_add_invalidate_notifier(closure, NULL, php_midgard_closure_invalidate);
+        g_closure_set_marshal((GClosure *)mgdclosure, php_midgard_closure_marshal);
+
+        return closure;
+}
+
+void php_midgard_gobject_connect(INTERNAL_FUNCTION_PARAMETERS)
+{
+        zval *callback;
+        gchar *sname = NULL;
+        guint sname_length;
+        guint signal_id;
+        zval *zval_object = getThis();
+        zval *zobject = NULL;
+        zval ***args = NULL;
+        GQuark signal_detail;
+        GClosure *closure = NULL;
+        zval ***params_array = NULL;
+
+        gint argc = ZEND_NUM_ARGS();
+
+        /* A function without parameters */
+        if(argc == 2) {
+                
+                if (zend_parse_parameters(2,  "sz", 
+                                        &sname, &sname_length, &callback)
+                                == FAILURE) {
+                        return;
+                }
+
+                argc = 0;
+        }
+
+        /* A method without parameters */
+        if(argc == 3) {
+                
+                if (zend_parse_parameters(3,  "szo",  
+                                        &sname, &sname_length, &callback,
+                                        &zobject, &args)
+                                == FAILURE) {
+                        return;
+                }
+
+                argc = 0;
+        }
+
+
+        /* A method or function with varargs */
+        if(argc > 3) {
+
+                args = (zval ***)safe_emalloc(argc, sizeof(zval **), 0);
+                if (zend_get_parameters_array_ex(argc, args) == FAILURE) {
+                        efree(args);
+                        WRONG_PARAM_COUNT;
+                }
+
+                /* Keep '!' as passed object parameter can be NULL */
+                if (zend_parse_parameters(3,  "szo!",
+                                        &sname, &sname_length,
+                                        &callback, &zobject)
+                                == FAILURE) {
+                        efree(args);
+                        return;
+                }
+
+                guint i;
+                
+                params_array = 
+                        (zval ***) emalloc(sizeof(zval **)*(argc-3));
+
+                for (i = 3; i < argc; i++) {
+                        
+                        params_array[i-3] = args[i];
+                }
+
+                efree(args);
+                /* Do not get signal name, function name and optional object */
+                argc = argc - 3; 
+        }
+
+        /* Get underlying GObject instance */
+        php_midgard_gobject *php_gobject =
+                (php_midgard_gobject *)zend_object_store_get_object(zval_object TSRMLS_CC);
+        GObject *object = G_OBJECT(php_gobject->gobject);
+
+        if (!g_signal_parse_name(sname, G_OBJECT_TYPE(object), 
+                                &signal_id, &signal_detail, TRUE)) {
+                php_error(E_WARNING, "%s signal name is invalid", sname);
+                return;
+                /* TODO , should we handle exception here? */
+        }
+
+        closure = php_midgard_closure_new(callback, zobject, params_array, argc);
+
+        if(!closure) {
+                php_error(E_WARNING, "Can not create new closure");
+                return;
+        }
+
+        g_signal_connect_closure_by_id(object, signal_id, signal_detail, closure, FALSE);
+}