mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-03-28 03:45:39 +00:00
Code Issues 1 Projects Releases Wiki Activity

Move DynamicSignals into the Gst namespace to prevent conflicts

Browse source
This commit is contained in:
Sebastian Dröge 2009-04-05 13:11:02 +02:00
parent f0a0b13d5f
commit 17739ad5de
5 changed files with 9 additions and 215 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
gstreamer-sharp/BindingHelper.cs
View file

@ -16,7 +16,7 @@ namespace Gst
public static class BindingHelper
{
public static Delegate AddProxySignalDelegate(Element element, string signal,
GLib.DynamicSignalHandler baseHandler, Delegate existingHandler, Delegate addHandler)
DynamicSignalHandler baseHandler, Delegate existingHandler, Delegate addHandler)
{
if(existingHandler == null) {
element.Connect(signal, baseHandler);
@ -26,7 +26,7 @@ namespace Gst
}
public static Delegate RemoveProxySignalDelegate(Element element, string signal,
GLib.DynamicSignalHandler baseHandler, Delegate existingHandler, Delegate removeHandler)
DynamicSignalHandler baseHandler, Delegate existingHandler, Delegate removeHandler)
{
Delegate temp_delegate = Delegate.Remove(existingHandler, removeHandler);
if(temp_delegate == null) {

4
gstreamer-sharp/DynamicSignal.cs
View file

@ -12,14 +12,14 @@ using System;
using System.Runtime.InteropServices;
using System.Collections;
namespace GLib {
namespace Gst {
public delegate void DynamicSignalHandler(object o, SignalArgs args);
delegate void GClosureMarshal (IntPtr closure, ref GLib.Value retval, uint argc, IntPtr argsPtr,
IntPtr invocation_hint, IntPtr data);
public class DynamicSignal {
public static class DynamicSignal {
private static readonly int gvalue_struct_size = Marshal.SizeOf(typeof(GLib.Value));

8
gstreamer-sharp/Element.custom
View file

@ -51,14 +51,14 @@
return gst_element_query_duration(Handle, ref format, out duration);
}
public void Connect(string signal, GLib.DynamicSignalHandler handler)
public void Connect(string signal, DynamicSignalHandler handler)
{
GLib.DynamicSignal.Connect(this, signal, handler);
DynamicSignal.Connect(this, signal, handler);
}
public void Disconnect(string signal, GLib.DynamicSignalHandler handler)
public void Disconnect(string signal, DynamicSignalHandler handler)
{
GLib.DynamicSignal.Disconnect(this, signal, handler);
DynamicSignal.Disconnect(this, signal, handler);
}
public bool AddPad(Pad p)

206
gstreamer-sharp/glue/dynamicsignal.c
View file

@ -1,206 +0,0 @@
//
// dynamicsignal.c: new method of registering GObject signal
// handlers that uses a default signal handler to read
// callback argument stack and convert to an array of
// GValues before running the "generic" signal handler
//
// Authors:
// Aaron Bockover (abockover@novell.com)
//
// (C) 2006 Novell, Inc.
//
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include <glib-object.h>
#include <gobject/gvaluecollector.h>
typedef void (* DynamicSignalHandler)(GObject *sender, guint argc,
GValue *argv, gpointer userdata);
//typedef gpointer (* DynamicSignalHandlerGPointer) (GObject *sender, guint argc,
// GValue *argv, gpointer userdata);
//typedef gint64 (* DynamicSignalHandlerGint64) (GObject *sender, guint argc, GValue *argv, gpointer userdata);
typedef struct {
GObject *object;
gpointer userdata;
/*
typedef union {
DynamicSignalHandler CBVoid;
DynamicSignalHandlerGPointer CBGPointer;
DynamicSignalHandlerGInt64 CBGInt64;
}
CallBack;
*/
DynamicSignalHandler callback;
guint id;
guint g_signal_id;
gulong handler_id;
GSignalQuery signal_details;
} DynamicSignalEntry;
static GList *dynamic_signal_table = NULL;
static guint dynamic_signal_last_id = 1;
static DynamicSignalEntry *
find_entry(GObject *object, guint signal_id)
{
GList *current = dynamic_signal_table;
while(current != NULL) {
DynamicSignalEntry *entry = (DynamicSignalEntry *)current->data;
if(entry->object == object && entry->g_signal_id == signal_id) {
return entry;
}
current = current->next;
}
return NULL;
}
static DynamicSignalEntry *
find_entry_by_name(GObject *object, const gchar *signal_name, guint *signal_id_out)
{
guint signal_id;
signal_id = g_signal_lookup(signal_name, G_OBJECT_TYPE(object));
if(signal_id_out != NULL) {
*signal_id_out = signal_id;
}
if(signal_id <= 0) {
return NULL;
}
return find_entry(object, signal_id);
}
static void
free_entry(DynamicSignalEntry *entry)
{
memset(entry, 0, sizeof(DynamicSignalEntry));
g_free(entry);
}
static void
dynamic_signal_handler(DynamicSignalEntry *entry, ...)
{
va_list argp;
GValue *args = NULL;
guint i, n;
if(entry == NULL) {
return;
}
n = entry->signal_details.n_params;
if(n <= 0) {
entry->callback(entry->object, 0, NULL, entry->userdata);
return;
}
args = g_new0(GValue, n);
va_start(argp, entry);
for(i = 0; i < n; i++) {
GType type = entry->signal_details.param_types[i];
GValue *value = &args[i];
gchar *collect_error = NULL;
if(!G_TYPE_IS_CLASSED(type) && G_TYPE_IS_VALUE_TYPE(type) &&
!G_TYPE_IS_FUNDAMENTAL(type) && G_TYPE_IS_DERIVED(type) &&
G_TYPE_HAS_VALUE_TABLE(type)) {
g_value_init(value, type);
value->data[0].v_pointer = va_arg(argp, gpointer);
} else {
g_value_init(value, type);
G_VALUE_COLLECT(value, argp, 0, &collect_error);
}
if(collect_error != NULL) {
g_warning("Could not collect value: %s", collect_error);
g_free(collect_error);
break;
}
}
va_end(argp);
entry->callback(entry->object, n, args, entry->userdata);
}
DynamicSignalEntry *
g_dynamic_signal_find_registration(GObject *object, const gchar *signal_name)
{
return find_entry_by_name(object, signal_name, NULL);
}
guint
g_dynamic_signal_connect(GObject *object, const gchar *signal_name,
DynamicSignalHandler callback, gboolean after, gpointer userdata)
{
DynamicSignalEntry *entry;
guint signal_id;
entry = find_entry_by_name(object, signal_name, &signal_id);
if(entry != NULL) {
return entry->id;
}
entry = g_new0(DynamicSignalEntry, 1);
entry->id = dynamic_signal_last_id++;
entry->object = object;
entry->g_signal_id = signal_id;
entry->callback = callback;
entry->userdata = userdata;
g_signal_query(signal_id, &(entry->signal_details));
dynamic_signal_table = g_list_prepend(dynamic_signal_table, entry);
entry->handler_id = g_signal_connect_data(object, signal_name,
G_CALLBACK(dynamic_signal_handler), entry, NULL,
G_CONNECT_SWAPPED | (after ? G_CONNECT_AFTER : 0));
return entry->id;
}
void
g_dynamic_signal_disconnect(GObject *object, const gchar *signal_name)
{
DynamicSignalEntry *entry = find_entry_by_name(object, signal_name, NULL);
if(entry == NULL) {
return;
}
g_signal_handler_disconnect(object, entry->handler_id);
dynamic_signal_table = g_list_remove(dynamic_signal_table, entry);
free_entry(entry);
entry = NULL;
}
void
g_dynamic_signal_update_entry_userdata(DynamicSignalEntry *entry, gpointer userdata)
{
if(entry != NULL) {
entry->userdata = userdata;
}
}
GType g_value_type(GValue *value)
{
return G_VALUE_TYPE(value);
}

2
gstreamer-sharp/plugins-base/TypeFindElement.cs
View file

@ -44,7 +44,7 @@ namespace Gst
BindingHelper.InvokeProxySignalDelegate(have_type_delegate, typeof(HaveTypeArgs), o, args);
}
public event GLib.DynamicSignalHandler HaveType {
public event HaveTypeHandler HaveType {
add {
have_type_delegate = BindingHelper.AddProxySignalDelegate(this, "have-type",
OnHaveType, have_type_delegate, value);