static JSValueRef
seed_gobject_signal_emit (JSContextRef ctx,
JSObjectRef function,
JSObjectRef thisObject,
size_t argumentCount,
const JSValueRef arguments[],
JSValueRef * exception)
{
JSValueRef ret;
GValue *params;
GValue ret_value = { 0 };
GSignalQuery query;
signal_privates *privates;
guint i, signal_id;
privates = JSObjectGetPrivate (thisObject);
signal_id = g_signal_lookup (privates->signal_name,
G_OBJECT_TYPE (privates->object));
g_signal_query (signal_id, &query);
if (argumentCount != query.n_params)
{
seed_make_exception (ctx, exception, "ArgumentError",
"Signal: %s for type %s expected %u "
"arguments, got %zd",
query.signal_name,
g_type_name (query.itype),
query.n_params, argumentCount);
return JSValueMakeNull (ctx);
}
params = g_new0 (GValue, argumentCount + 1);
g_value_init (¶ms[0], G_TYPE_OBJECT);
g_value_set_object (¶ms[0], privates->object);
for (i = 0; i < argumentCount; i++)
seed_value_to_gvalue (ctx, arguments[i],
query.param_types[i],
¶ms[i + 1], exception);
if (query.return_type != G_TYPE_NONE)
g_value_init (&ret_value, query.return_type);
g_signal_emitv (params, signal_id, 0, &ret_value);
for (i = 0; i < argumentCount; i++)
g_value_unset (¶ms[i]);
g_free (params);
ret = seed_value_from_gvalue (ctx, &ret_value, exception);
if (query.return_type != G_TYPE_NONE)
g_value_unset (&ret_value);
return ret;
}
static void
print_element_signals (GstElement * element, gint pfx)
{
guint *signals;
guint nsignals;
gint i, k;
GSignalQuery *query;
signals = g_signal_list_ids (G_OBJECT_TYPE (element), &nsignals);
for (k = 0; k < 2; k++) {
gint counted = 0;
if (k == 0)
PUT_START_TAG (pfx, "element-signals");
else
PUT_START_TAG (pfx, "element-actions");
for (i = 0; i < nsignals; i++) {
gint n_params;
GType return_type;
const GType *param_types;
gint j;
query = g_new0 (GSignalQuery, 1);
g_signal_query (signals[i], query);
if ((k == 0 && !(query->signal_flags & G_SIGNAL_ACTION)) ||
(k == 1 && (query->signal_flags & G_SIGNAL_ACTION))) {
n_params = query->n_params;
return_type = query->return_type;
param_types = query->param_types;
PUT_START_TAG (pfx + 1, "signal");
PUT_ESCAPED (pfx + 2, "name", query->signal_name);
PUT_ESCAPED (pfx + 2, "return-type", g_type_name (return_type));
PUT_ESCAPED (pfx + 2, "object-type",
g_type_name (G_OBJECT_TYPE (element)));
PUT_START_TAG (pfx + 2, "params");
for (j = 0; j < n_params; j++) {
PUT_ESCAPED (pfx + 3, "type", g_type_name (param_types[j]));
}
PUT_END_TAG (pfx + 2, "params");
PUT_END_TAG (pfx + 1, "signal");
counted++;
}
g_free (query);
}
if (k == 0)
PUT_END_TAG (pfx, "element-signals");
else
PUT_END_TAG (pfx, "element-actions");
}
}
/**
* autoar_common_g_signal_emit:
* @instance: the instance the signal is being emitted on.
* @in_thread: %TRUE if you are not call this function inside the main thread.
* @signal_id: the signal id
* @detail: the detail
* @...: parameters to be passed to the signal.
*
* This is a wrapper for g_signal_emit(). If @in_thread is %FALSE, this
* function is the same as g_signal_emit(). If @in_thread is %TRUE, the
* signal will be emitted from the main thread. This function will send
* the signal emission job via g_main_context_invoke(), but it does not
* wait for the signal emission job to be completed. Hence, the signal
* may emitted after autoar_common_g_signal_emit() is returned.
**/
G_GNUC_INTERNAL void
autoar_common_g_signal_emit (gpointer instance,
gboolean in_thread,
guint signal_id,
GQuark detail,
...)
{
va_list ap;
va_start (ap, detail);
if (in_thread) {
int i;
gchar *error;
GSignalQuery query;
AutoarCommonSignalData *data;
error = NULL;
data = g_new0 (AutoarCommonSignalData, 1);
data->signal_id = signal_id;
data->detail = detail;
data->used_values = 1;
g_value_init (data->instance_and_params, G_TYPE_FROM_INSTANCE (instance));
g_value_set_instance (data->instance_and_params, instance);
g_signal_query (signal_id, &query);
if (query.signal_id == 0) {
autoar_common_signal_data_free (data);
va_end (ap);
return;
}
for (i = 0; i < query.n_params; i++) {
G_VALUE_COLLECT_INIT (data->instance_and_params + i + 1,
query.param_types[i],
ap,
0,
&error);
if (error != NULL)
break;
data->used_values++;
}
if (error == NULL) {
g_main_context_invoke (NULL, autoar_common_g_signal_emit_main_context, data);
} else {
autoar_common_signal_data_free (data);
g_debug ("G_VALUE_COLLECT_INIT: Error: %s", error);
g_free (error);
va_end (ap);
return;
}
} else {
g_signal_emit_valist (instance, signal_id, detail, ap);
}
va_end (ap);
}
gulong
seed_gobject_signal_connect (JSContextRef ctx,
const gchar * signal_name,
GObject * on_obj,
JSObjectRef func,
JSObjectRef this_obj, JSObjectRef user_data)
{
GSignalQuery query;
GClosure *closure;
if (g_str_has_prefix (signal_name, "notify::"))
g_signal_query (g_signal_lookup ("notify", G_OBJECT_TYPE (on_obj)),
&query);
else
g_signal_query (g_signal_lookup (signal_name, G_OBJECT_TYPE (on_obj)),
&query);
#ifdef SEED_ENABLE_DEBUG
{
guint function_arity = seed_value_to_uint (ctx,
seed_object_get_property (ctx,
func,
"length"),
NULL);
if (function_arity != query.n_params)
{
SEED_MARK ();
SEED_NOTE (SIGNAL,
"Connecting signal: %s. Function has arity %d, signal expects %d",
query.signal_name, function_arity, query.n_params);
SEED_MARK ();
}
}
#endif
closure = seed_closure_new_for_signal (ctx, func, user_data, "signal handler", query.signal_id);
// This seems wrong...
((SeedClosure *) closure)->return_type = query.return_type;
return g_signal_connect_closure (on_obj, signal_name, closure, FALSE);
}
void
gtk_signal_emitv (GtkObject *object,
guint signal_id,
GtkArg *args)
{
GSignalQuery query;
GValue params[SIGNAL_MAX_PARAMS + 1] = { { 0, }, };
GValue rvalue = { 0, };
guint i;
g_return_if_fail (GTK_IS_OBJECT (object));
g_signal_query (signal_id, &query);
g_return_if_fail (query.signal_id != 0);
g_return_if_fail (g_type_is_a (GTK_OBJECT_TYPE (object), query.itype));
g_return_if_fail (query.n_params < SIGNAL_MAX_PARAMS);
if (query.n_params > 0)
g_return_if_fail (args != NULL);
g_value_init (params + 0, GTK_OBJECT_TYPE (object));
g_value_set_object (params + 0, G_OBJECT (object));
for (i = 0; i < query.n_params; i++)
{
GValue *value = params + 1 + i;
GtkArg *arg = args + i;
g_value_init (value, arg->type & ~G_SIGNAL_TYPE_STATIC_SCOPE);
if (!gtk_arg_static_to_value (arg, value))
{
g_warning ("%s: failed to convert arg type `%s' to value type `%s'",
G_STRLOC, g_type_name (arg->type & ~G_SIGNAL_TYPE_STATIC_SCOPE),
g_type_name (G_VALUE_TYPE (value)));
return;
}
}
if (query.return_type != G_TYPE_NONE)
g_value_init (&rvalue, query.return_type);
g_signal_emitv (params, signal_id, 0, &rvalue);
if (query.return_type != G_TYPE_NONE)
{
gtk_argloc_set_from_value (args + query.n_params, &rvalue, TRUE);
g_value_unset (&rvalue);
}
for (i = 0; i < query.n_params; i++)
g_value_unset (params + 1 + i);
g_value_unset (params + 0);
}
static gboolean
spi_application_toolkit_event_listener (GSignalInvocationHint *signal_hint,
guint n_param_values,
const GValue *param_values,
gpointer data)
{
Accessibility_Event e;
AtkObject *aobject;
SpiAccessible *source;
GSignalQuery signal_query;
char *event_name;
g_return_val_if_fail (the_app != NULL, FALSE);
g_signal_query (signal_hint->signal_id, &signal_query);
/* TODO: move GTK reference out of app.c into bridge */
event_name = g_strdup_printf ("Gtk:%s:%s",
g_type_name (signal_query.itype),
signal_query.signal_name);
#ifdef SPI_DEBUG
fprintf (stderr, "Received signal %s\n", event_name);
#endif
aobject = get_atk_object_ref (g_value_get_object (param_values + 0));
source = spi_accessible_new (aobject);
e.type = CORBA_string_dup (event_name);
e.source = CORBA_OBJECT_NIL;
e.detail1 = 0;
e.detail2 = 0;
spi_init_any_nil (&e.any_data,
spi_accessible_new_return (atk_get_root (), FALSE, NULL),
Accessibility_ROLE_UNKNOWN,
"");
notify_listeners (the_app->toolkit_listeners, source, &e);
bonobo_object_unref (BONOBO_OBJECT (source));
g_object_unref (G_OBJECT (aobject));
g_free (event_name);
return TRUE;
}
void
gtk_signal_emit_by_name (GtkObject *object,
const gchar *name,
...)
{
GSignalQuery query;
va_list var_args;
g_return_if_fail (GTK_IS_OBJECT (object));
g_return_if_fail (name != NULL);
g_signal_query (g_signal_lookup (name, GTK_OBJECT_TYPE (object)), &query);
g_return_if_fail (query.signal_id != 0);
va_start (var_args, name);
g_signal_emit_valist (G_OBJECT (object), query.signal_id, 0, var_args);
va_end (var_args);
}
static void
ec_style_set_recursive (GnomeCanvasItem *item, GtkStyle *previous_style)
{
guint signal_id = g_signal_lookup ("style_set", G_OBJECT_TYPE (item));
if (signal_id >= 1) {
GSignalQuery query;
g_signal_query (signal_id, &query);
if (query.return_type == G_TYPE_NONE && query.n_params == 1 && query.param_types[0] == GTK_TYPE_STYLE) {
g_signal_emit (item, signal_id, 0, previous_style);
}
}
if (GNOME_IS_CANVAS_GROUP (item) ) {
GList *items = GNOME_CANVAS_GROUP (item)->item_list;
for (; items; items = items->next)
ec_style_set_recursive (items->data, previous_style);
}
}
static gboolean
window_event_listener (GSignalInvocationHint * signal_hint,
guint n_param_values,
const GValue * param_values, gpointer data)
{
AtkObject *accessible;
GSignalQuery signal_query;
const gchar *name, *s;
g_signal_query (signal_hint->signal_id, &signal_query);
name = signal_query.signal_name;
accessible = ATK_OBJECT (g_value_get_object (¶m_values[0]));
s = atk_object_get_name (accessible);
g_print ("Detected window event \"%s\" from object \"%p\" named \"%s\"\n",
name, accessible, s);
return TRUE;
}
static void
plugin_connect_action (GigglePlugin *plugin,
GtkAction *action)
{
guint *signals, n_signals, i;
GSignalQuery query;
signals = g_signal_list_ids (G_OBJECT_TYPE (action), &n_signals);
for (i = 0; i < n_signals; ++i) {
g_signal_query (signals[i], &query);
if (G_TYPE_NONE != query.return_type || query.n_params > 0)
continue;
g_signal_connect (action, query.signal_name,
G_CALLBACK (plugin_action_cb), plugin);
}
g_free (signals);
}
static gboolean axObjectEventListener(GSignalInvocationHint *signalHint,
guint numParamValues,
const GValue *paramValues,
gpointer data)
{
// At least we should receive the instance emitting the signal.
if (numParamValues < 1)
return TRUE;
AtkObject* accessible = ATK_OBJECT(g_value_get_object(¶mValues[0]));
if (!accessible || !ATK_IS_OBJECT(accessible))
return TRUE;
GSignalQuery signal_query;
GOwnPtr<gchar> signalName;
g_signal_query(signalHint->signal_id, &signal_query);
if (!g_strcmp0(signal_query.signal_name, "state-change")) {
signalName.set(g_strdup_printf("state-change:%s = %d",
g_value_get_string(¶mValues[1]),
g_value_get_boolean(¶mValues[2])));
} else if (!g_strcmp0(signal_query.signal_name, "focus-event")) {
signalName.set(g_strdup_printf("focus-event = %d",
g_value_get_boolean(¶mValues[1])));
} else if (!g_strcmp0(signal_query.signal_name, "children-changed")) {
signalName.set(g_strdup_printf("children-changed = %d",
g_value_get_uint(¶mValues[1])));
} else if (!g_strcmp0(signal_query.signal_name, "property-change")) {
signalName.set(g_strdup_printf("property-change:%s",
g_quark_to_string(signalHint->detail)));
} else
signalName.set(g_strdup(signal_query.signal_name));
printAccessibilityEvent(accessible, signalName.get());
return TRUE;
}
void
seed_signal_marshal_func (GClosure * closure,
GValue * return_value,
guint n_param_values,
const GValue * param_values,
gpointer invocation_hint, gpointer marshal_data)
{
SeedClosure *seed_closure = (SeedClosure *) closure;
JSValueRef *args, exception = 0;
JSValueRef ret = 0;
guint i;
gchar *mes;
GSignalQuery signal_query = { 0, };
if (marshal_data)
{
/* Inspired from gjs/gi/value.c:closure_marshal() */
/* we are used for a signal handler */
guint signal_id;
signal_id = GPOINTER_TO_UINT(marshal_data);
g_signal_query(signal_id, &signal_query);
if (!signal_query.signal_id)
g_error("Signal handler being called on invalid signal");
if (signal_query.n_params + 1 != n_param_values)
g_error("Signal handler being called with wrong number of parameters");
}
JSContextRef ctx = JSGlobalContextCreateInGroup (context_group,
0);
seed_prepare_global_context (ctx);
SEED_NOTE (INVOCATION, "Signal Marshal: ");
args = g_newa (JSValueRef, n_param_values + 1);
for (i = 0; i < n_param_values; i++)
{
args[i] = seed_value_from_gvalue_for_signal (ctx,
(GValue *) & param_values[i], 0, &signal_query, i);
if (!args[i])
g_error ("Error in signal marshal. "
"Unable to convert argument of type: %s \n",
g_type_name (param_values[i].g_type));
}
if (seed_closure->user_data)
args[i] = seed_closure->user_data;
else
args[i] = JSValueMakeNull (ctx);
ret = JSObjectCallAsFunction (ctx, seed_closure->function,
NULL, n_param_values + 1, args, &exception);
if (exception)
{
seed_closure_warn_exception (closure, ctx, exception);
exception = NULL;
}
if (ret && !JSValueIsNull (ctx, ret)
&& (seed_closure->return_type != G_TYPE_NONE))
{
seed_value_to_gvalue (ctx, ret, seed_closure->return_type,
return_value, &exception);
}
if (exception)
{
mes = seed_exception_to_string (ctx, exception);
g_warning ("Exception in signal handler return value. %s \n", mes);
g_free (mes);
}
JSGlobalContextRelease ((JSGlobalContextRef) ctx);
JSGarbageCollect(ctx);
}
static gboolean axObjectEventListener(GSignalInvocationHint *signalHint, guint numParamValues, const GValue *paramValues, gpointer data)
{
// At least we should receive the instance emitting the signal.
if (numParamValues < 1)
return true;
AtkObject* accessible = ATK_OBJECT(g_value_get_object(¶mValues[0]));
if (!accessible || !ATK_IS_OBJECT(accessible))
return true;
GSignalQuery signalQuery;
GUniquePtr<gchar> signalName;
GUniquePtr<gchar> signalValue;
String notificationName;
g_signal_query(signalHint->signal_id, &signalQuery);
if (!g_strcmp0(signalQuery.signal_name, "state-change")) {
signalName.reset(g_strdup_printf("state-change:%s", g_value_get_string(¶mValues[1])));
signalValue.reset(g_strdup_printf("%d", g_value_get_boolean(¶mValues[2])));
if (!g_strcmp0(g_value_get_string(¶mValues[1]), "checked"))
notificationName = "CheckedStateChanged";
else if (!g_strcmp0(g_value_get_string(¶mValues[1]), "invalid-entry"))
notificationName = "AXInvalidStatusChanged";
} else if (!g_strcmp0(signalQuery.signal_name, "focus-event")) {
signalName.reset(g_strdup("focus-event"));
signalValue.reset(g_strdup_printf("%d", g_value_get_boolean(¶mValues[1])));
if (g_value_get_boolean(¶mValues[1]))
notificationName = "AXFocusedUIElementChanged";
} else if (!g_strcmp0(signalQuery.signal_name, "children-changed")) {
const gchar* childrenChangedDetail = g_quark_to_string(signalHint->detail);
signalName.reset(g_strdup_printf("children-changed:%s", childrenChangedDetail));
signalValue.reset(g_strdup_printf("%d", g_value_get_uint(¶mValues[1])));
notificationName = !g_strcmp0(childrenChangedDetail, "add") ? "AXChildrenAdded" : "AXChildrenRemoved";
} else if (!g_strcmp0(signalQuery.signal_name, "property-change")) {
signalName.reset(g_strdup_printf("property-change:%s", g_quark_to_string(signalHint->detail)));
if (!g_strcmp0(g_quark_to_string(signalHint->detail), "accessible-value"))
notificationName = "AXValueChanged";
} else if (!g_strcmp0(signalQuery.signal_name, "load-complete"))
notificationName = "AXLoadComplete";
else
signalName.reset(g_strdup(signalQuery.signal_name));
if (loggingAccessibilityEvents)
printAccessibilityEvent(accessible, signalName.get(), signalValue.get());
#if PLATFORM(GTK)
JSGlobalContextRef jsContext = webkit_web_frame_get_global_context(mainFrame);
#elif PLATFORM(EFL)
JSGlobalContextRef jsContext = DumpRenderTreeSupportEfl::globalContextRefForFrame(browser->mainFrame());
#else
JSContextRef jsContext = 0;
#endif
if (!jsContext)
return true;
if (notificationName.length()) {
JSRetainPtr<JSStringRef> jsNotificationEventName(Adopt, JSStringCreateWithUTF8CString(notificationName.utf8().data()));
JSValueRef notificationNameArgument = JSValueMakeString(jsContext, jsNotificationEventName.get());
NotificationHandlersMap::iterator elementNotificationHandler = notificationHandlers.find(accessible);
if (elementNotificationHandler != notificationHandlers.end()) {
// Listener for one element just gets one argument, the notification name.
JSObjectCallAsFunction(jsContext, elementNotificationHandler->value->notificationFunctionCallback(), 0, 1, ¬ificationNameArgument, 0);
}
if (globalNotificationHandler) {
// A global listener gets the element and the notification name as arguments.
JSValueRef arguments[2];
arguments[0] = AccessibilityUIElement::makeJSAccessibilityUIElement(jsContext, AccessibilityUIElement(accessible));
arguments[1] = notificationNameArgument;
JSObjectCallAsFunction(jsContext, globalNotificationHandler->notificationFunctionCallback(), 0, 2, arguments, 0);
}
}
return true;
}
/* Handle key event (it is either key-press or key-release) by focusable actor
* which has the focus or by specified actor.
*/
gboolean xfdashboard_focus_manager_handle_key_event(XfdashboardFocusManager *self, const ClutterEvent *inEvent, XfdashboardFocusable *inFocusable)
{
XfdashboardFocusManagerPrivate *priv;
g_return_val_if_fail(XFDASHBOARD_IS_FOCUS_MANAGER(self), CLUTTER_EVENT_PROPAGATE);
g_return_val_if_fail(inEvent, CLUTTER_EVENT_PROPAGATE);
g_return_val_if_fail(clutter_event_type(inEvent)==CLUTTER_KEY_PRESS || clutter_event_type(inEvent)==CLUTTER_KEY_RELEASE, CLUTTER_EVENT_PROPAGATE);
g_return_val_if_fail(!inFocusable || XFDASHBOARD_IS_FOCUSABLE(inFocusable), CLUTTER_EVENT_PROPAGATE);
priv=self->priv;
/* If no focusable actor was specified then use current focused actor */
if(!inFocusable)
{
inFocusable=priv->currentFocus;
/* If still no focusable actor is available we cannot handle event
* so let the others try it by propagating event.
*/
if(!inFocusable) return(CLUTTER_EVENT_PROPAGATE);
}
/* Synthesize event for specified focusable actor */
if(inFocusable)
{
XfdashboardBindingsPool *bindings;
const XfdashboardBinding *binding;
gboolean eventStatus;
/* Take reference on ourselve and the focusable actor to keep them alive when handling event */
g_object_ref(self);
g_object_ref(inFocusable);
/* Lookup action for event and emit action if a binding was found
* for this event.
*/
eventStatus=CLUTTER_EVENT_PROPAGATE;
bindings=xfdashboard_bindings_pool_get_default();
binding=xfdashboard_bindings_pool_find_for_event(bindings, CLUTTER_ACTOR(inFocusable), inEvent);
if(binding)
{
const gchar *target;
const gchar *action;
GSList *targetFocusables;
GSList *iter;
GSignalQuery signalData={ 0, };
/* Get action of binding */
action=xfdashboard_binding_get_action(binding);
/* Build up list of targets which is either the requested focusable actor,
* the current focused actor or focusable actors of a specific type
*/
targetFocusables=NULL;
target=xfdashboard_binding_get_target(binding);
if(target)
{
/* Target class name is specified so build up a list of targets */
targetFocusables=_xfdashboard_focus_manager_get_targets_for_binding(self, binding);
}
else
{
/* No target class name was specified so add requested focusable
* actor to list of target.
*/
targetFocusables=g_slist_append(targetFocusables, g_object_ref(inFocusable));
}
g_debug("Target list for action '%s' has %d actors",
action,
g_slist_length(targetFocusables));
/* Emit action of binding to each actor in target list just build up */
for(iter=targetFocusables; iter; iter=g_slist_next(iter))
{
GObject *targetObject;
guint signalID;
/* Get target to emit action signal at */
targetObject=G_OBJECT(iter->data);
/* Check if target provides action requested as signal */
signalID=g_signal_lookup(action, G_OBJECT_TYPE(targetObject));
if(!signalID)
{
g_warning(_("Object type %s does not provide action '%s'"),
G_OBJECT_TYPE_NAME(targetObject),
action);
continue;
}
/* Query signal for detailed data */
g_signal_query(signalID, &signalData);
/* Check if signal is an action signal */
if(!(signalData.signal_flags & G_SIGNAL_ACTION))
{
g_warning(_("Action '%s' at object type %s is not an action signal."),
action,
G_OBJECT_TYPE_NAME(targetObject));
continue;
}
#if DEBUG
/* In debug mode also check if signal has right signature
* to be able to handle this action properly.
*/
if(signalID)
{
GType returnValueType=G_TYPE_BOOLEAN;
GType parameterTypes[]={ XFDASHBOARD_TYPE_FOCUSABLE, G_TYPE_STRING, CLUTTER_TYPE_EVENT };
guint parameterCount;
guint i;
/* Check if signal wants the right type of return value */
if(signalData.return_type!=returnValueType)
{
g_critical(_("Action '%s' at object type %s wants return value of type %s but expected is %s."),
action,
G_OBJECT_TYPE_NAME(targetObject),
g_type_name(signalData.return_type),
g_type_name(returnValueType));
}
/* Check if signals wants the right number and types of parameters */
parameterCount=sizeof(parameterTypes)/sizeof(GType);
if(signalData.n_params!=parameterCount)
{
g_critical(_("Action '%s' at object type %s wants %u parameters but expected are %u."),
action,
G_OBJECT_TYPE_NAME(targetObject),
signalData.n_params,
parameterCount);
}
for(i=0; i<(parameterCount<signalData.n_params ? parameterCount : signalData.n_params); i++)
{
if(signalData.param_types[i]!=parameterTypes[i])
{
g_critical(_("Action '%s' at object type %s wants type %s at parameter %u but type %s is expected."),
action,
G_OBJECT_TYPE_NAME(targetObject),
g_type_name(signalData.param_types[i]),
i+1,
g_type_name(parameterTypes[i]));
}
}
}
#endif
/* Emit action signal at target */
g_debug("Emitting action signal '%s' at focusable actor %s",
action,
G_OBJECT_TYPE_NAME(targetObject));
g_signal_emit_by_name(targetObject, action, inFocusable, action, inEvent, &eventStatus);
g_debug("Action signal '%s' was %s by focusable actor %s",
action,
eventStatus==CLUTTER_EVENT_STOP ? "handled" : "not handled",
G_OBJECT_TYPE_NAME(targetObject));
}
/* Release allocated resources */
g_slist_free_full(targetFocusables, g_object_unref);
}
g_object_unref(bindings);
/* Release reference on ourselve and the focusable actor to took to keep them alive */
g_object_unref(inFocusable);
g_object_unref(self);
if(eventStatus==CLUTTER_EVENT_STOP) return(CLUTTER_EVENT_STOP);
}
/* Event was not handled so synthesize event to specified focusable actor */
return(clutter_actor_event(CLUTTER_ACTOR(inFocusable), inEvent, FALSE));
}
static void
print_signal_info (GstElement * element)
{
/* Signals/Actions Block */
guint *signals;
guint nsignals;
gint i = 0, j, k;
GSignalQuery *query = NULL;
GType type;
GSList *found_signals, *l;
for (k = 0; k < 2; k++) {
found_signals = NULL;
/* For elements that have sometimes pads, also list a few useful GstElement
* signals. Put these first, so element-specific ones come later. */
if (k == 0 && has_sometimes_template (element)) {
query = g_new0 (GSignalQuery, 1);
g_signal_query (g_signal_lookup ("pad-added", GST_TYPE_ELEMENT), query);
found_signals = g_slist_append (found_signals, query);
query = g_new0 (GSignalQuery, 1);
g_signal_query (g_signal_lookup ("pad-removed", GST_TYPE_ELEMENT), query);
found_signals = g_slist_append (found_signals, query);
query = g_new0 (GSignalQuery, 1);
g_signal_query (g_signal_lookup ("no-more-pads", GST_TYPE_ELEMENT),
query);
found_signals = g_slist_append (found_signals, query);
}
for (type = G_OBJECT_TYPE (element); type; type = g_type_parent (type)) {
if (type == GST_TYPE_ELEMENT || type == GST_TYPE_OBJECT)
break;
if (type == GST_TYPE_BIN && G_OBJECT_TYPE (element) != GST_TYPE_BIN)
continue;
signals = g_signal_list_ids (type, &nsignals);
for (i = 0; i < nsignals; i++) {
query = g_new0 (GSignalQuery, 1);
g_signal_query (signals[i], query);
if ((k == 0 && !(query->signal_flags & G_SIGNAL_ACTION)) ||
(k == 1 && (query->signal_flags & G_SIGNAL_ACTION)))
found_signals = g_slist_append (found_signals, query);
else
g_free (query);
}
g_free (signals);
signals = NULL;
}
if (found_signals) {
n_print ("\n");
if (k == 0)
n_print ("Element Signals:\n");
else
n_print ("Element Actions:\n");
} else {
continue;
}
for (l = found_signals; l; l = l->next) {
gchar *indent;
const gchar *pmark;
int indent_len;
query = (GSignalQuery *) l->data;
indent_len = strlen (query->signal_name) +
strlen (g_type_name (query->return_type)) + 24;
if (query->return_type == G_TYPE_POINTER) {
pmark = "";
} else if (G_TYPE_FUNDAMENTAL (query->return_type) == G_TYPE_POINTER
|| G_TYPE_IS_BOXED (query->return_type)
|| G_TYPE_IS_OBJECT (query->return_type)) {
pmark = "* ";
indent_len += 2;
} else {
pmark = "";
}
indent = g_new0 (gchar, indent_len + 1);
memset (indent, ' ', indent_len);
n_print (" \"%s\" : %s %suser_function (%s* object",
query->signal_name, g_type_name (query->return_type), pmark,
g_type_name (type));
for (j = 0; j < query->n_params; j++) {
g_print (",\n");
if (G_TYPE_IS_FUNDAMENTAL (query->param_types[j])) {
n_print ("%s%s arg%d", indent,
g_type_name (query->param_types[j]), j);
} else if (G_TYPE_IS_ENUM (query->param_types[j])) {
n_print ("%s%s arg%d", indent,
g_type_name (query->param_types[j]), j);
} else {
n_print ("%s%s* arg%d", indent,
g_type_name (query->param_types[j]), j);
}
}
if (k == 0) {
g_print (",\n");
n_print ("%sgpointer user_data);\n", indent);
} else
g_print (");\n");
g_free (indent);
}
if (found_signals) {
g_slist_foreach (found_signals, (GFunc) g_free, NULL);
g_slist_free (found_signals);
}
}
}
static void
language_support_add_c_callback (CppJavaPlugin* lang_plugin,
IAnjutaEditor* editor,
IAnjutaIterable* position,
GStrv split_signal_data,
CppFileType filetype)
{
GSignalQuery query;
gchar* separator;
gchar* body;
gint offset;
const gchar* widget = split_signal_data[0];
const gchar* signal = split_signal_data[1];
const gchar* handler = split_signal_data[2];
const gchar* user_data = split_signal_data[3];
gboolean swapped = g_str_equal (split_signal_data[4], "1");
GType type = g_type_from_name (widget);
guint id = g_signal_lookup (signal, type);
g_signal_query (id, &query);
if (!language_support_get_callback_strings (&separator, &body, &offset, user_data, editor, filetype))
return;
GString* str = language_support_generate_c_signature (separator, widget,
query, swapped, handler);
g_string_append (str, body);
ianjuta_document_begin_undo_action (IANJUTA_DOCUMENT(editor), NULL);
ianjuta_editor_insert (editor, position,
str->str, -1, NULL);
ianjuta_document_end_undo_action (IANJUTA_DOCUMENT(editor), NULL);
/* Code was inserted, we'll now check if we should add a prototype to the header */
if (filetype == LS_FILE_C)
{
IAnjutaEditor* header_editor;
IAnjutaIterable* mark_position;
mark_position = language_support_get_header_editor_and_mark (lang_plugin,
editor,
"/* Callbacks */",
&header_editor);
if (mark_position)
{
/* Check if there's a the prototype to the header */
IAnjutaIterable* symbol;
symbol = language_support_find_symbol (lang_plugin, header_editor, handler);
if (symbol)
{
g_object_unref (symbol);
} else {
/* Add prototype to the header */
language_support_add_c_callback (lang_plugin, header_editor, mark_position,
split_signal_data, LS_FILE_CHDR);
g_signal_emit_by_name (G_OBJECT (header_editor), "code-changed", NULL, NULL);
}
g_object_unref (mark_position);
}
}
gchar *string = g_string_free (str, FALSE);
/* Emit code-added signal, so symbols will be updated */
g_signal_emit_by_name (G_OBJECT (editor), "code-changed", position, string);
if (string) g_free (string);
/* Body is a bit different form other strings and must be freed */
if (body) g_free (body);
/* Will now set the caret position offset */
ianjuta_editor_goto_line (editor,
ianjuta_editor_get_line_from_position (
editor, position, NULL) + offset, NULL);
}
static gboolean axObjectEventListener(GSignalInvocationHint *signalHint, guint numParamValues, const GValue *paramValues, gpointer data)
{
// At least we should receive the instance emitting the signal.
if (numParamValues < 1)
return TRUE;
AtkObject* accessible = ATK_OBJECT(g_value_get_object(¶mValues[0]));
if (!accessible || !ATK_IS_OBJECT(accessible))
return TRUE;
GSignalQuery signalQuery;
GOwnPtr<gchar> signalName;
GOwnPtr<gchar> signalValue;
String notificationName;
g_signal_query(signalHint->signal_id, &signalQuery);
if (!g_strcmp0(signalQuery.signal_name, "state-change")) {
signalName.set(g_strdup_printf("state-change:%s", g_value_get_string(¶mValues[1])));
signalValue.set(g_strdup_printf("%d", g_value_get_boolean(¶mValues[2])));
if (!g_strcmp0(g_value_get_string(¶mValues[1]), "checked"))
notificationName = "CheckedStateChanged";
} else if (!g_strcmp0(signalQuery.signal_name, "focus-event")) {
signalName.set(g_strdup("focus-event"));
signalValue.set(g_strdup_printf("%d", g_value_get_boolean(¶mValues[1])));
notificationName = "AXFocusedUIElementChanged";
} else if (!g_strcmp0(signalQuery.signal_name, "children-changed")) {
signalName.set(g_strdup("children-changed"));
signalValue.set(g_strdup_printf("%d", g_value_get_uint(¶mValues[1])));
} else if (!g_strcmp0(signalQuery.signal_name, "property-change"))
signalName.set(g_strdup_printf("property-change:%s", g_quark_to_string(signalHint->detail)));
else
signalName.set(g_strdup(signalQuery.signal_name));
if (loggingAccessibilityEvents)
printAccessibilityEvent(accessible, signalName.get(), signalValue.get());
#if PLATFORM(GTK)
JSGlobalContextRef jsContext = webkit_web_frame_get_global_context(mainFrame);
#else
JSContextRef jsContext = 0;
#endif
if (!jsContext)
return TRUE;
if (notificationName.length()) {
for (HashMap<PlatformUIElement, AccessibilityNotificationHandler*>::iterator it = notificationHandlers.begin(); it != notificationHandlers.end(); ++it) {
if (it->key == accessible || it->key == GlobalNotificationKey) {
JSRetainPtr<JSStringRef> jsNotificationEventName(Adopt, JSStringCreateWithUTF8CString(reinterpret_cast<const char*>(notificationName.utf8().data())));
JSValueRef notificationNameArgument = JSValueMakeString(jsContext, jsNotificationEventName.get());
AccessibilityNotificationHandler* notificationHandler = it->value;
if (notificationHandler->platformElement()) {
JSValueRef argument = notificationNameArgument;
// Listener for one element just gets one argument, the notification name.
JSObjectCallAsFunction(jsContext, notificationHandler->notificationFunctionCallback(), 0, 1, &argument, 0);
} else {
// A global listener gets the element and the notification name as arguments.
JSValueRef arguments[2];
arguments[0] = AccessibilityUIElement::makeJSAccessibilityUIElement(jsContext, AccessibilityUIElement(accessible));
arguments[1] = notificationNameArgument;
JSObjectCallAsFunction(jsContext, notificationHandler->notificationFunctionCallback(), 0, 2, arguments, 0);
}
}
}
}
return TRUE;
}
int
main (int argc, char **argv)
{
gint i;
GTest *test1, *test2;
GArray *test_threads;
const gint n_threads = 1;
#ifdef SYMBIAN
g_log_set_handler (NULL, G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);
g_set_print_handler(mrtPrintHandler);
#endif /*SYMBIAN*/
g_thread_init (NULL);
#ifndef SYMBIAN
g_print ("START: %s\n", argv[0]);
#else
#ifdef VERBOSE
g_print ("START: %s\n", argv[0]);
#endif
#endif /*SYMBIAN*/
g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | g_log_set_always_fatal (G_LOG_FATAL_MASK));
g_type_init ();
test1 = g_object_new (G_TYPE_TEST, NULL);
test2 = g_object_new (G_TYPE_TEST, NULL);
g_signal_connect (test1, "notify::test-prop", G_CALLBACK (notify), NULL);
g_signal_connect (test1, "test-signal1", G_CALLBACK (notify), NULL);
g_signal_connect (test1, "test-signal2", G_CALLBACK (notify), NULL);
#ifndef SYMBIAN
test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));
stopping = FALSE;
for (i = 0; i < n_threads; i++) {
GThread *thread;
thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);
g_array_append_val (test_threads, thread);
thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);
g_array_append_val (test_threads, thread);
}
g_usleep (500000);
stopping = TRUE;
g_print ("\nstopping\n");
/* join all threads */
for (i = 0; i < 2 * n_threads; i++) {
GThread *thread;
thread = g_array_index (test_threads, GThread *, i);
g_thread_join (thread);
}
g_print ("stopped:%d\n",TESTNUM);
#else
#ifdef MULTITHREAD
test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));
stopping = FALSE;
TESTNUM=1;
notifynum=0;
handlernum=0;
for (i = 0; i < n_threads; i++)
{
GThread *thread;
thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);
g_array_append_val (test_threads, thread);
thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);
g_array_append_val (test_threads, thread);
}
g_usleep (500000);
stopping = TRUE;
#ifdef VERBOSE
g_print ("\nstopping\n");
#endif
/* join all threads */
for (i = 0; i < 2 * n_threads; i++)
{
GThread *thread;
thread = g_array_index (test_threads, GThread *, i);
g_thread_join (thread);
}
g_assert(notifynum != 0);
g_assert(handlernum == 0);
g_array_free (test_threads, TRUE);
#ifdef VERBOSE
g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM);
#endif
test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));
stopping = FALSE;
TESTNUM=2;
notifynum=0;
handlernum=0;
for (i = 0; i < n_threads; i++)
{
GThread *thread;
thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);
g_array_append_val (test_threads, thread);
thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);
g_array_append_val (test_threads, thread);
}
g_usleep (500000);
stopping = TRUE;
#ifdef VERBOSE
g_print ("\nstopping\n");
#endif
/* join all threads */
for (i = 0; i < 2 * n_threads; i++)
{
GThread *thread;
thread = g_array_index (test_threads, GThread *, i);
g_thread_join (thread);
}
g_assert(notifynum != 0);
g_assert(handlernum != 0);
g_array_free (test_threads, TRUE);
#ifdef VERBOSE
g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM);
#endif
test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));
stopping = FALSE;
TESTNUM=3;
notifynum=0;
handlernum=0;
for (i = 0; i < n_threads; i++)
{
GThread *thread;
thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);
g_array_append_val (test_threads, thread);
thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);
g_array_append_val (test_threads, thread);
}
g_usleep (5000000);
stopping = TRUE;
#ifdef VERBOSE
g_print ("\nstopping\n");
#endif
/* join all threads */
for (i = 0; i < 2 * n_threads; i++)
{
GThread *thread;
thread = g_array_index (test_threads, GThread *, i);
g_thread_join (thread);
}
g_assert(notifynum != 0);
g_assert(handlernum == 0);
g_array_free (test_threads, TRUE);
#ifdef VERBOSE
g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM);
#endif
#else /* ! MULTITHREAD*/
TESTNUM=1;
#ifdef VERBOSE
g_print ("\nStarting with TESTNUM=%d\n",TESTNUM);
#endif
notifynum=0;
handlernum=0;
run_thread(test1);
g_assert(notifynum == LOOP +1);
g_assert(handlernum ==0);
notifynum=0;
handlernum=0;
run_thread(test2);
g_assert(notifynum == 0);
g_assert(handlernum == 0);
TESTNUM=2;
#ifdef VERBOSE
g_print ("\nStarting with TESTNUM=%d\n",TESTNUM);
#endif
notifynum=0;
handlernum=0;
run_thread(test1);
g_assert(notifynum == LOOP+1);
g_assert(handlernum == LOOP+1);
notifynum=0;
handlernum=0;
run_thread(test2);
g_assert(notifynum == 0);
g_assert(handlernum == LOOP+1);
TESTNUM=3;
#ifdef VERBOSE
g_print ("\nStarting with TESTNUM=%d\n",TESTNUM);
#endif
notifynum=0;
handlernum=0;
run_thread(test1);
g_assert(notifynum == LOOP +1);
g_assert(handlernum ==0);
notifynum=0;
handlernum=0;
run_thread(test2);
g_assert(notifynum == 0);
g_assert(handlernum == 0);
g_assert(g_signal_has_handler_pending(G_OBJECT(test1),g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,TRUE)==TRUE);
g_assert(g_signal_has_handler_pending(G_OBJECT(test2),g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,TRUE)==FALSE);
g_assert(g_signal_handler_is_connected(G_OBJECT(test1),g_signal_lookup("test-signal1",G_TYPE_TEST))==TRUE);
g_assert(g_signal_handler_is_connected(G_OBJECT(test2),g_signal_lookup("test-signal2",G_TYPE_TEST))==FALSE);
handlernum=g_signal_lookup("test-signal1",G_TYPE_TEST);
#ifdef VERBOSE
g_print("Signal id: %d\n",handlernum);
#endif
g_signal_connect (test2, "test-signal1", G_CALLBACK (notify), NULL);
hookid=g_signal_add_emission_hook(handlernum,NULL,(GSignalEmissionHook) hook_function,NULL,NULL);
#ifdef VERBOSE
g_print("Hookid: %d\n",hookid);
#endif
/********************/
#ifdef TEST_STOP_EMISSION
/*
notifynum=0;
handlernum=0;
g_print("The following call stops signal emission\n");
g_signal_stop_emission(G_OBJECT(test1),g_signal_lookup("test-signal1",G_TYPE_TEST),0);
g_print("The following call should abort and it is normal\n");
run_thread(test1);
printf("Notifynum: %d and Handlernum: %d\n",notifynum,handlernum);
*/
notifynum=0;
handlernum=0;
g_signal_stop_emission_by_name(G_OBJECT(test1),"test-signal1");
//run_thread(test1);
g_print("Notifynum: %d and Handlernum: %d\n",notifynum,handlernum);
#endif /*TEST_STOP_EMISSION*/
/*******************/
handlernum=0;
g_signal_emit(G_OBJECT (test1), g_test_signals[TEST_SIGNAL1], 0, 0);
g_signal_emit(G_OBJECT (test2), g_test_signals[TEST_SIGNAL1], 0, 0);
g_assert(handlernum==2);
g_signal_remove_emission_hook(g_signal_lookup("test-signal1",G_TYPE_TEST),hookid);
#ifdef VERBOSE
g_print("Emitting signal again after removing emission hook\n");
#endif
handlernum=0;
g_signal_emit (G_OBJECT (test1), g_test_signals[TEST_SIGNAL1], 0, 0);
g_signal_emit (G_OBJECT (test2), g_test_signals[TEST_SIGNAL1], 0, 0);
g_assert(handlernum==0);
g_assert (strcmp ("test-signal1", g_signal_name (g_signal_lookup("test-signal1",G_TYPE_TEST))) == 0);
g_assert (strcmp ("test-signal2", g_signal_name (g_signal_lookup("test-signal2",G_TYPE_TEST))) == 0);
memset(&gv,0,sizeof(gv));
g_value_init(&gv,G_TYPE_OBJECT);
g_value_set_object(&gv,test1);
gi=0;
g_signal_list_ids(G_OBJECT_TYPE(test1),&gi);
g_assert(g_signal_lookup("test-signal1",G_TYPE_TEST)==gi);
notifynum=0;
g_signal_emitv (&gv, g_test_signals[TEST_SIGNAL1], 0, &gv);
g_assert(notifynum==1);
g_signal_query(g_signal_lookup("test-signal1",G_TYPE_TEST),&gq);
g_assert(strcmp("test-signal1",gq.signal_name)==0);
g_assert(g_signal_lookup("test-signal1",G_TYPE_TEST)==gq.signal_id);
g_assert(g_signal_handler_find(G_OBJECT(test1), G_SIGNAL_RUN_LAST,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,NULL,NULL)==2);
notifynum=g_signal_handlers_block_matched(G_OBJECT(test1),G_SIGNAL_MATCH_FUNC,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,(gpointer)G_CALLBACK(notify),NULL);
handlernum=g_signal_handlers_unblock_matched(G_OBJECT(test1),G_SIGNAL_MATCH_FUNC,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,(gpointer)G_CALLBACK(notify),NULL);
g_assert(notifynum==handlernum);
#endif /*MULTITHREAD*/
#ifdef VERBOSE
g_printf ("\nsignals-multithread.c: Completed all tests\n");
#endif
#endif /*SYMBIAN*/
#if SYMBIAN
testResultXml("signals-singlethread");
#endif /* EMULATOR */
return 0;
}
static void
print_signal_info (GstElement * element)
{
/* Signals/Actions Block */
guint *signals;
guint nsignals;
gint i = 0, j, k;
GSignalQuery *query = NULL;
GType type;
GSList *found_signals, *l;
for (k = 0; k < 2; k++) {
found_signals = NULL;
for (type = G_OBJECT_TYPE (element); type; type = g_type_parent (type)) {
if (type == GST_TYPE_ELEMENT || type == GST_TYPE_OBJECT)
break;
if (type == GST_TYPE_BIN && G_OBJECT_TYPE (element) != GST_TYPE_BIN)
continue;
signals = g_signal_list_ids (type, &nsignals);
for (i = 0; i < nsignals; i++) {
query = g_new0 (GSignalQuery, 1);
g_signal_query (signals[i], query);
if ((k == 0 && !(query->signal_flags & G_SIGNAL_ACTION)) ||
(k == 1 && (query->signal_flags & G_SIGNAL_ACTION)))
found_signals = g_slist_append (found_signals, query);
else
g_free (query);
}
g_free (signals);
signals = NULL;
}
if (found_signals) {
n_print ("\n");
if (k == 0)
n_print ("Element Signals:\n");
else
n_print ("Element Actions:\n");
} else {
continue;
}
for (l = found_signals; l; l = l->next) {
gchar *indent;
int indent_len;
query = (GSignalQuery *) l->data;
indent_len = strlen (query->signal_name) +
strlen (g_type_name (query->return_type)) + 24;
indent = g_new0 (gchar, indent_len + 1);
memset (indent, ' ', indent_len);
n_print (" \"%s\" : %s user_function (%s* object",
query->signal_name,
g_type_name (query->return_type), g_type_name (type));
for (j = 0; j < query->n_params; j++) {
if (_name)
g_print ("%s", _name);
if (G_TYPE_IS_FUNDAMENTAL (query->param_types[j])) {
g_print (",\n%s%s arg%d", indent,
g_type_name (query->param_types[j]), j);
} else if (G_TYPE_IS_ENUM (query->param_types[j])) {
g_print (",\n%s%s arg%d", indent,
g_type_name (query->param_types[j]), j);
} else {
g_print (",\n%s%s* arg%d", indent,
g_type_name (query->param_types[j]), j);
}
}
if (k == 0) {
if (_name)
g_print ("%s", _name);
g_print (",\n%sgpointer user_data);\n", indent);
} else
g_print (");\n");
g_free (indent);
}
if (found_signals) {
g_slist_foreach (found_signals, (GFunc) g_free, NULL);
g_slist_free (found_signals);
}
}
}
static void
closure_marshal(GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data)
{
JSRuntime *runtime;
JSContext *context;
int argc;
jsval *argv;
jsval rval;
int i;
GSignalQuery signal_query = { 0, };
gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
"Marshal closure %p",
closure);
if (!gjs_closure_is_valid(closure)) {
/* We were destroyed; become a no-op */
return;
}
runtime = gjs_closure_get_runtime(closure);
context = gjs_runtime_get_current_context(runtime);
JS_BeginRequest(context);
argc = n_param_values;
argv = g_newa(jsval, n_param_values);
rval = JSVAL_VOID;
gjs_set_values(context, argv, argc, JSVAL_VOID);
gjs_root_value_locations(context, argv, argc);
JS_AddValueRoot(context, &rval);
if (marshal_data) {
/* we are used for a signal handler */
guint signal_id;
signal_id = GPOINTER_TO_UINT(marshal_data);
g_signal_query(signal_id, &signal_query);
if (!signal_query.signal_id) {
gjs_debug(GJS_DEBUG_GCLOSURE,
"Signal handler being called on invalid signal");
goto cleanup;
}
if (signal_query.n_params + 1 != n_param_values) {
gjs_debug(GJS_DEBUG_GCLOSURE,
"Signal handler being called with wrong number of parameters");
goto cleanup;
}
}
for (i = 0; i < argc; ++i) {
const GValue *gval = ¶m_values[i];
gboolean no_copy;
no_copy = FALSE;
if (i >= 1 && signal_query.signal_id) {
no_copy = (signal_query.param_types[i - 1] & G_SIGNAL_TYPE_STATIC_SCOPE) != 0;
}
if (!gjs_value_from_g_value_internal(context, &argv[i], gval, no_copy, &signal_query, i)) {
gjs_debug(GJS_DEBUG_GCLOSURE,
"Unable to convert arg %d in order to invoke closure",
i);
gjs_log_exception(context, NULL);
goto cleanup;
}
}
gjs_closure_invoke(closure, argc, argv, &rval);
if (return_value != NULL) {
if (JSVAL_IS_VOID(rval)) {
/* something went wrong invoking, error should be set already */
goto cleanup;
}
if (!gjs_value_to_g_value(context, rval, return_value)) {
gjs_debug(GJS_DEBUG_GCLOSURE,
"Unable to convert return value when invoking closure");
gjs_log_exception(context, NULL);
goto cleanup;
}
}
cleanup:
gjs_unroot_value_locations(context, argv, argc);
JS_RemoveValueRoot(context, &rval);
JS_EndRequest(context);
}
/* This button was clicked */
static void _xfdashboard_action_button_clicked(XfdashboardButton *inButton)
{
XfdashboardActionButton *self;
XfdashboardActionButtonPrivate *priv;
GSList *targets;
GSList *iter;
g_return_if_fail(XFDASHBOARD_IS_ACTION_BUTTON(inButton));
self=XFDASHBOARD_ACTION_BUTTON(inButton);
priv=self->priv;
targets=NULL;
/* Get target object to perform action at */
targets=xfdashboard_focus_manager_get_targets(priv->focusManager, priv->target);
XFDASHBOARD_DEBUG(self, ACTOR, "Target list for '%s' has %d entries",
priv->target,
g_slist_length(targets));
/* Emit action at each actor in target list */
for(iter=targets; iter; iter=g_slist_next(iter))
{
GObject *targetObject;
guint signalID;
GSignalQuery signalData={ 0, };
const ClutterEvent *event;
gboolean eventStatus;
/* Get target to emit action signal at */
targetObject=G_OBJECT(iter->data);
/* Check if target provides action requested as signal */
signalID=g_signal_lookup(priv->action, G_OBJECT_TYPE(targetObject));
if(!signalID)
{
g_warning(_("Object type %s does not provide action '%s'"),
G_OBJECT_TYPE_NAME(targetObject),
priv->action);
continue;
}
/* Query signal for detailed data */
g_signal_query(signalID, &signalData);
/* Check if signal is an action signal */
if(!(signalData.signal_flags & G_SIGNAL_ACTION))
{
g_warning(_("Action '%s' at object type %s is not an action signal."),
priv->action,
G_OBJECT_TYPE_NAME(targetObject));
continue;
}
/* In debug mode also check if signal has right signature
* to be able to handle this action properly.
*/
if(signalID)
{
GType returnValueType=G_TYPE_BOOLEAN;
GType parameterTypes[]={ XFDASHBOARD_TYPE_FOCUSABLE, G_TYPE_STRING, CLUTTER_TYPE_EVENT };
guint parameterCount;
guint i;
/* Check if signal wants the right type of return value */
if(signalData.return_type!=returnValueType)
{
g_critical(_("Action '%s' at object type %s wants return value of type %s but expected is %s."),
priv->action,
G_OBJECT_TYPE_NAME(targetObject),
g_type_name(signalData.return_type),
g_type_name(returnValueType));
}
/* Check if signals wants the right number and types of parameters */
parameterCount=sizeof(parameterTypes)/sizeof(GType);
if(signalData.n_params!=parameterCount)
{
g_critical(_("Action '%s' at object type %s wants %u parameters but expected are %u."),
priv->action,
G_OBJECT_TYPE_NAME(targetObject),
signalData.n_params,
parameterCount);
}
for(i=0; i<(parameterCount<signalData.n_params ? parameterCount : signalData.n_params); i++)
{
if(signalData.param_types[i]!=parameterTypes[i])
{
g_critical(_("Action '%s' at object type %s wants type %s at parameter %u but type %s is expected."),
priv->action,
G_OBJECT_TYPE_NAME(targetObject),
g_type_name(signalData.param_types[i]),
i+1,
g_type_name(parameterTypes[i]));
}
}
}
/* Emit action signal at target */
XFDASHBOARD_DEBUG(self, ACTOR, "Emitting action signal '%s' at actor %s",
priv->action,
G_OBJECT_TYPE_NAME(targetObject));
event=clutter_get_current_event();
eventStatus=CLUTTER_EVENT_PROPAGATE;
g_signal_emit_by_name(targetObject,
priv->action,
XFDASHBOARD_FOCUSABLE(self),
priv->action,
event,
&eventStatus);
XFDASHBOARD_DEBUG(self, ACTOR, "Action signal '%s' was %s by actor %s",
priv->action,
eventStatus==CLUTTER_EVENT_STOP ? "handled" : "not handled",
G_OBJECT_TYPE_NAME(targetObject));
}
/* Release allocated resources */
if(targets) g_slist_free_full(targets, g_object_unref);
}
std::string
get_signals(GType gtype, GTypeIsAPointerFunc is_a_pointer_func)
{
std::string strResult;
std::string strObjectName = g_type_name(gtype);
gpointer gclass_ref = nullptr;
gpointer ginterface_ref = nullptr;
if (G_TYPE_IS_OBJECT(gtype))
gclass_ref = g_type_class_ref(gtype); // Ensures that class_init() is called.
else if (G_TYPE_IS_INTERFACE(gtype))
ginterface_ref = g_type_default_interface_ref(gtype); // install signals.
// Get the list of signals:
guint iCount = 0;
guint* pIDs = g_signal_list_ids(gtype, &iCount);
// Loop through the list of signals:
if (pIDs)
{
for (guint i = 0; i < iCount; i++)
{
guint signal_id = pIDs[i];
// Name:
std::string strName = g_signal_name(signal_id);
strResult += "(define-signal " + strName + "\n";
strResult += " (of-object \"" + strObjectName + "\")\n";
// Other information about the signal:
GSignalQuery signalQuery = {
0, nullptr, 0, GSignalFlags(0), 0, 0, nullptr,
};
g_signal_query(signal_id, &signalQuery);
// Return type:
std::string strReturnTypeName =
get_type_name_signal(signalQuery.return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE,
is_a_pointer_func); // The type is mangled with a flag. Hacky.
// bool bReturnTypeHasStaticScope = (signalQuery.return_type & G_SIGNAL_TYPE_STATIC_SCOPE) ==
// G_SIGNAL_TYPE_STATIC_SCOPE;
strResult += " (return-type \"" + strReturnTypeName + "\")\n";
// Flags:
std::string strFlags;
add_signal_flag_if(strFlags, "Run First", signalQuery, G_SIGNAL_RUN_FIRST);
add_signal_flag_if(strFlags, "Run Last", signalQuery, G_SIGNAL_RUN_LAST);
add_signal_flag_if(strFlags, "Run Cleanup", signalQuery, G_SIGNAL_RUN_CLEANUP);
add_signal_flag_if(strFlags, "No Recurse", signalQuery, G_SIGNAL_NO_RECURSE);
add_signal_flag_if(strFlags, "Action", signalQuery, G_SIGNAL_ACTION);
add_signal_flag_if(strFlags, "No Hooks", signalQuery, G_SIGNAL_NO_HOOKS);
add_signal_flag_if(strFlags, "Must Collect", signalQuery, G_SIGNAL_MUST_COLLECT);
strResult += " (flags \"" + strFlags + "\")\n";
if (signalQuery.signal_flags & G_SIGNAL_DETAILED)
strResult += " (detailed #t)\n"; // Default: not detailed
if (signalQuery.signal_flags & G_SIGNAL_DEPRECATED)
strResult += " (deprecated #t)\n"; // Default: not deprecated
// Loop through the list of parameters:
const GType* pParameters = signalQuery.param_types;
if (pParameters)
{
strResult += " (parameters\n";
for (unsigned j = 0; j < signalQuery.n_params; j++)
{
GType typeParamMangled = pParameters[j];
// Parameter name:
// We can't get the real parameter name from the GObject system. It's not registered with
// g_signal_new().
gchar* pchNum = g_strdup_printf("%d", j);
std::string strParamName = "p" + std::string(pchNum);
g_free(pchNum);
pchNum = nullptr;
// Just like above, for the return type:
std::string strTypeName =
get_type_name_signal(typeParamMangled & ~G_SIGNAL_TYPE_STATIC_SCOPE,
is_a_pointer_func); // The type is mangled with a flag. Hacky.
// bool bTypeHasStaticScope = (typeParamMangled & G_SIGNAL_TYPE_STATIC_SCOPE) ==
// G_SIGNAL_TYPE_STATIC_SCOPE;
strResult += " '(\"" + strTypeName + "\" \"" + strParamName + "\")\n";
}
strResult += " )\n"; // close (parameters
}
strResult += ")\n\n"; // close (define-signal
}
}
g_free(pIDs);
if (gclass_ref)
g_type_class_unref(gclass_ref); // to match the g_type_class_ref() above.
else if (ginterface_ref)
g_type_default_interface_unref(ginterface_ref); // for interface ref above.
return strResult;
}
/**
* Create one of our custom GClosure subclasses. To save us having to export
* it, however, we just return the GClosure* that it extends.
*/
GClosure*
bindings_java_closure_new
(
JNIEnv* env,
jobject handler,
jclass receiver,
const gchar* name,
guint id
)
{
GClosure* closure;
BindingsJavaClosure* bjc;
GSignalQuery info;
GString* buf;
guint i;
gchar* methodName;
gchar* methodSignature;
/*
* First we allocate the closure and do the footwork to tell it what
* its marshaller is
*/
closure = g_closure_new_simple(sizeof(BindingsJavaClosure), NULL);
g_closure_add_finalize_notifier(closure, NULL, bindings_java_closure_destroy);
g_closure_set_marshal(closure, bindings_java_marshaller);
bjc = (BindingsJavaClosure*) closure;
/*
* And now we begin the legwork of figuring out what the methodID of
* the callback to be invoked is and caching that in the closure. We
* get the GSignalQuery data for the specified signal and then use that
* to formulate a string that can be use to lookup the method.
*/
g_signal_query(id, &info);
switch(G_TYPE_FUNDAMENTAL(info.return_type)) {
case G_TYPE_BOOLEAN:
bjc->returnType = 'Z';
break;
case G_TYPE_INT:
bjc->returnType = 'I';
break;
case G_TYPE_ENUM:
bjc->returnType = 'E';
break;
case G_TYPE_STRING:
/*
* Strings are encoded as java.lang.String objects in signatures,
* so we use the object type marker for gchar* (only).
*/
bjc->returnType = 'L';
break;
case G_TYPE_NONE:
bjc->returnType = 'V';
break;
default:
g_critical("Don't know what to do with signal return type %s", g_type_name(info.return_type));
return NULL;
}
/*
* the name of the methods we invoke is algorithmic: "receiveName",
* where Name is a PascalCase version of the signal name we were
* passed in.
*/
buf = g_string_new("receive");
gchar** tokens = g_strsplit_set(name, "_-:", -1);
for (i = 0; i < g_strv_length(tokens); i++) {
gchar* token = tokens[i];
if (token[0] == '\0') {
// skip past :: which splits signal name from "detail"
continue;
}
gchar first = g_unichar_toupper(token[0]);
g_string_append_c(buf, first);
token++;
g_string_append(buf, token);
}
methodName = buf->str;
g_string_free(buf, FALSE);
g_strfreev(tokens);
/*
* And here is the tricky bit: formulate the method signature that goes
* along with this signal. A method of the signature
*
* boolean method(int, long, String)
*
* has a JNI encoding of
*
* (IJLjava/util/String;)Z
*/
buf = g_string_new("(Lorg/gnome/glib/Signal;J");
// add the signature for each parameter type
for(i = 0; i < info.n_params; i++) {
g_string_append(buf, bindings_java_typeToSignature(info.param_types[i]));
}
// and the return type
g_string_append(buf, ")");
g_string_append(buf, bindings_java_typeToSignature(info.return_type));
methodSignature = buf->str;
g_string_free(buf, FALSE);
/*
* Now at last we can lookup the method ID
*/
// jclass CANDIDATE = (*env)->FindClass(env, "org/gnome/gtk/GtkWidget");
// if ((*env)->IsSameObject(env, CANDIDATE, receiver)) {
// g_debug("Received a GtkWidget");
// }
bjc->receiver = receiver;
bjc->method = (*env)->GetStaticMethodID(env, bjc->receiver, methodName, methodSignature);
// g_debug("Looking for\nJava method %s\nwith signature %s\nin class %s\nto handle signal %s\n",
// methodName, methodSignature, "FIXME", g_signal_name(id));
// clean up
g_free(methodName);
g_free(methodSignature);
// and check for error
if (bjc->method == NULL) {
// Exception already thrown by GetMethodID
return NULL;
}
/*
* Set the reference so that the marshaller can find the Signal instance.
*/
bjc->handler = (*env)->NewWeakGlobalRef(env, handler);
/*
* And we're done!
*/
return closure;
}
static void
on_glade_drop (IAnjutaEditor* editor,
IAnjutaIterable* iterator,
const gchar* signal_data,
PythonPlugin* lang_plugin)
{
GSignalQuery query;
GType type;
guint id;
const gchar* widget;
const gchar* signal;
const gchar* handler;
const gchar* user_data;
gboolean swapped;
GList* names = NULL;
GString* str = g_string_new (NULL);
int i;
IAnjutaIterable* start, * end;
GStrv data = g_strsplit(signal_data, ":", 5);
widget = data[0];
signal = data[1];
handler = data[2];
user_data = data[3];
swapped = g_str_equal (data[4], "1");
type = g_type_from_name (widget);
id = g_signal_lookup (signal, type);
g_signal_query (id, &query);
g_string_append_printf (str, "\ndef %s (self", handler);
for (i = 0; i < query.n_params; i++)
{
const gchar* type_name = g_type_name (query.param_types[i]);
const gchar* param_name = language_support_get_signal_parameter (type_name,
&names);
g_string_append_printf (str, ", %s", param_name);
}
g_string_append (str, "):\n");
ianjuta_editor_insert (editor, iterator,
str->str, -1, NULL);
/* Indent code correctly */
start = iterator;
end = ianjuta_iterable_clone (iterator, NULL);
ianjuta_iterable_set_position (end,
ianjuta_iterable_get_position (iterator, NULL)
+ g_utf8_strlen (str->str, -1),
NULL);
ianjuta_indenter_indent (IANJUTA_INDENTER (lang_plugin),
start, end, NULL);
g_object_unref (end);
g_string_free (str, TRUE);
anjuta_util_glist_strings_free (names);
g_strfreev (data);
}
