From a4e2955c7c8fc33fc066c03714644cf9989f5c0c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Fri, 31 Jul 2009 10:16:55 +0200 Subject: [PATCH] Add copy of glib-sharp from trunk This is for internal usage only and will be removed once there's a working glib-sharp release. This also contains the required patches from README. --- gstreamer-sharp/glib-sharp/Argv.cs | 89 +++ gstreamer-sharp/glib-sharp/Boxed.cs | 62 ++ .../glib-sharp/CDeclCallbackAttribute.cs | 30 + .../glib-sharp/ClassInitializerAttribute.cs | 31 + .../glib-sharp/ConnectBeforeAttribute.cs | 30 + .../DefaultSignalHandlerAttribute.cs | 53 ++ gstreamer-sharp/glib-sharp/DelegateWrapper.cs | 111 +++ gstreamer-sharp/glib-sharp/DestroyNotify.cs | 52 ++ gstreamer-sharp/glib-sharp/EnumWrapper.cs | 42 + .../glib-sharp/ExceptionManager.cs | 74 ++ gstreamer-sharp/glib-sharp/FileUtils.cs | 48 ++ gstreamer-sharp/glib-sharp/Format.cs | 39 + gstreamer-sharp/glib-sharp/GException.cs | 57 ++ .../glib-sharp/GInterfaceAdapter.cs | 64 ++ .../glib-sharp/GInterfaceAttribute.cs | 42 + gstreamer-sharp/glib-sharp/GString.cs | 60 ++ gstreamer-sharp/glib-sharp/GType.cs | 426 ++++++++++ gstreamer-sharp/glib-sharp/GTypeAttribute.cs | 42 + gstreamer-sharp/glib-sharp/Global.cs | 68 ++ gstreamer-sharp/glib-sharp/IOChannel.cs | 469 +++++++++++ gstreamer-sharp/glib-sharp/IWrapper.cs | 30 + gstreamer-sharp/glib-sharp/Idle.cs | 125 +++ .../IgnoreClassInitializersAttribute.cs | 31 + .../glib-sharp/InitiallyUnowned.cs | 46 ++ gstreamer-sharp/glib-sharp/List.cs | 97 +++ gstreamer-sharp/glib-sharp/ListBase.cs | 279 +++++++ gstreamer-sharp/glib-sharp/Log.cs | 191 +++++ gstreamer-sharp/glib-sharp/MainContext.cs | 56 ++ gstreamer-sharp/glib-sharp/MainLoop.cs | 71 ++ gstreamer-sharp/glib-sharp/ManagedValue.cs | 149 ++++ gstreamer-sharp/glib-sharp/Markup.cs | 46 ++ gstreamer-sharp/glib-sharp/Marshaller.cs | 413 ++++++++++ .../glib-sharp/MissingIntPtrCtorException.cs | 35 + gstreamer-sharp/glib-sharp/NotifyHandler.cs | 35 + gstreamer-sharp/glib-sharp/Object.cs | 738 ++++++++++++++++++ gstreamer-sharp/glib-sharp/ObjectManager.cs | 89 +++ gstreamer-sharp/glib-sharp/Opaque.cs | 150 ++++ gstreamer-sharp/glib-sharp/ParamSpec.cs | 206 +++++ gstreamer-sharp/glib-sharp/Priority.cs | 31 + .../glib-sharp/PropertyAttribute.cs | 69 ++ gstreamer-sharp/glib-sharp/PtrArray.cs | 272 +++++++ gstreamer-sharp/glib-sharp/SList.cs | 99 +++ gstreamer-sharp/glib-sharp/Signal.cs | 421 ++++++++++ gstreamer-sharp/glib-sharp/SignalArgs.cs | 68 ++ gstreamer-sharp/glib-sharp/SignalAttribute.cs | 47 ++ gstreamer-sharp/glib-sharp/SignalCallback.cs | 106 +++ gstreamer-sharp/glib-sharp/SignalClosure.cs | 227 ++++++ gstreamer-sharp/glib-sharp/Source.cs | 62 ++ gstreamer-sharp/glib-sharp/Spawn.cs | 216 +++++ gstreamer-sharp/glib-sharp/Thread.cs | 49 ++ gstreamer-sharp/glib-sharp/Timeout.cs | 135 ++++ gstreamer-sharp/glib-sharp/ToggleRef.cs | 159 ++++ gstreamer-sharp/glib-sharp/TypeConverter.cs | 36 + .../glib-sharp/TypeFundamentals.cs | 47 ++ .../glib-sharp/TypeInitializerAttribute.cs | 48 ++ gstreamer-sharp/glib-sharp/UnwrappedObject.cs | 40 + gstreamer-sharp/glib-sharp/Value.cs | 675 ++++++++++++++++ gstreamer-sharp/glib-sharp/ValueArray.cs | 247 ++++++ gstreamer-sharp/glib-sharp/WeakObject.cs | 0 59 files changed, 7730 insertions(+) create mode 100644 gstreamer-sharp/glib-sharp/Argv.cs create mode 100644 gstreamer-sharp/glib-sharp/Boxed.cs create mode 100644 gstreamer-sharp/glib-sharp/CDeclCallbackAttribute.cs create mode 100644 gstreamer-sharp/glib-sharp/ClassInitializerAttribute.cs create mode 100644 gstreamer-sharp/glib-sharp/ConnectBeforeAttribute.cs create mode 100644 gstreamer-sharp/glib-sharp/DefaultSignalHandlerAttribute.cs create mode 100644 gstreamer-sharp/glib-sharp/DelegateWrapper.cs create mode 100644 gstreamer-sharp/glib-sharp/DestroyNotify.cs create mode 100644 gstreamer-sharp/glib-sharp/EnumWrapper.cs create mode 100644 gstreamer-sharp/glib-sharp/ExceptionManager.cs create mode 100644 gstreamer-sharp/glib-sharp/FileUtils.cs create mode 100644 gstreamer-sharp/glib-sharp/Format.cs create mode 100644 gstreamer-sharp/glib-sharp/GException.cs create mode 100644 gstreamer-sharp/glib-sharp/GInterfaceAdapter.cs create mode 100644 gstreamer-sharp/glib-sharp/GInterfaceAttribute.cs create mode 100644 gstreamer-sharp/glib-sharp/GString.cs create mode 100644 gstreamer-sharp/glib-sharp/GType.cs create mode 100644 gstreamer-sharp/glib-sharp/GTypeAttribute.cs create mode 100644 gstreamer-sharp/glib-sharp/Global.cs create mode 100644 gstreamer-sharp/glib-sharp/IOChannel.cs create mode 100644 gstreamer-sharp/glib-sharp/IWrapper.cs create mode 100644 gstreamer-sharp/glib-sharp/Idle.cs create mode 100644 gstreamer-sharp/glib-sharp/IgnoreClassInitializersAttribute.cs create mode 100644 gstreamer-sharp/glib-sharp/InitiallyUnowned.cs create mode 100644 gstreamer-sharp/glib-sharp/List.cs create mode 100644 gstreamer-sharp/glib-sharp/ListBase.cs create mode 100644 gstreamer-sharp/glib-sharp/Log.cs create mode 100644 gstreamer-sharp/glib-sharp/MainContext.cs create mode 100644 gstreamer-sharp/glib-sharp/MainLoop.cs create mode 100644 gstreamer-sharp/glib-sharp/ManagedValue.cs create mode 100644 gstreamer-sharp/glib-sharp/Markup.cs create mode 100644 gstreamer-sharp/glib-sharp/Marshaller.cs create mode 100644 gstreamer-sharp/glib-sharp/MissingIntPtrCtorException.cs create mode 100644 gstreamer-sharp/glib-sharp/NotifyHandler.cs create mode 100644 gstreamer-sharp/glib-sharp/Object.cs create mode 100644 gstreamer-sharp/glib-sharp/ObjectManager.cs create mode 100644 gstreamer-sharp/glib-sharp/Opaque.cs create mode 100644 gstreamer-sharp/glib-sharp/ParamSpec.cs create mode 100644 gstreamer-sharp/glib-sharp/Priority.cs create mode 100644 gstreamer-sharp/glib-sharp/PropertyAttribute.cs create mode 100644 gstreamer-sharp/glib-sharp/PtrArray.cs create mode 100644 gstreamer-sharp/glib-sharp/SList.cs create mode 100644 gstreamer-sharp/glib-sharp/Signal.cs create mode 100644 gstreamer-sharp/glib-sharp/SignalArgs.cs create mode 100644 gstreamer-sharp/glib-sharp/SignalAttribute.cs create mode 100644 gstreamer-sharp/glib-sharp/SignalCallback.cs create mode 100644 gstreamer-sharp/glib-sharp/SignalClosure.cs create mode 100644 gstreamer-sharp/glib-sharp/Source.cs create mode 100644 gstreamer-sharp/glib-sharp/Spawn.cs create mode 100644 gstreamer-sharp/glib-sharp/Thread.cs create mode 100644 gstreamer-sharp/glib-sharp/Timeout.cs create mode 100644 gstreamer-sharp/glib-sharp/ToggleRef.cs create mode 100644 gstreamer-sharp/glib-sharp/TypeConverter.cs create mode 100644 gstreamer-sharp/glib-sharp/TypeFundamentals.cs create mode 100644 gstreamer-sharp/glib-sharp/TypeInitializerAttribute.cs create mode 100644 gstreamer-sharp/glib-sharp/UnwrappedObject.cs create mode 100644 gstreamer-sharp/glib-sharp/Value.cs create mode 100644 gstreamer-sharp/glib-sharp/ValueArray.cs create mode 100644 gstreamer-sharp/glib-sharp/WeakObject.cs diff --git a/gstreamer-sharp/glib-sharp/Argv.cs b/gstreamer-sharp/glib-sharp/Argv.cs new file mode 100644 index 0000000000..6f5d09307a --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Argv.cs @@ -0,0 +1,89 @@ +// GLib.Argv.cs : Argv marshaling class +// +// Author: Mike Kestner +// +// Copyright (c) 2004 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + public class Argv { + + IntPtr[] arg_ptrs; + IntPtr handle; + bool add_progname = false; + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_malloc(IntPtr size); + + [DllImport("libglib-2.0-0.dll")] + static extern void g_free (IntPtr mem); + + ~Argv () + { + foreach (IntPtr arg in arg_ptrs) + g_free (arg); + + g_free (handle); + } + + public Argv (string[] args) : this (args, false) {} + + public Argv (string[] args, bool add_program_name) + { + add_progname = add_program_name; + if (add_progname) { + string[] full = new string [args.Length + 1]; + full [0] = System.Environment.GetCommandLineArgs ()[0]; + args.CopyTo (full, 1); + args = full; + } + + arg_ptrs = new IntPtr [args.Length]; + + for (int i = 0; i < args.Length; i++) + arg_ptrs [i] = Marshaller.StringToPtrGStrdup (args[i]); + + handle = g_malloc (new IntPtr (IntPtr.Size * args.Length)); + + for (int i = 0; i < args.Length; i++) + Marshal.WriteIntPtr (handle, i * IntPtr.Size, arg_ptrs [i]); + } + + public IntPtr Handle { + get { + return handle; + } + } + + public string[] GetArgs (int argc) + { + int count = add_progname ? argc - 1 : argc; + int idx = add_progname ? 1 : 0; + string[] result = new string [count]; + + for (int i = 0; i < count; i++, idx++) + result [i] = Marshaller.Utf8PtrToString (Marshal.ReadIntPtr (handle, idx * IntPtr.Size)); + + return result; + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/Boxed.cs b/gstreamer-sharp/glib-sharp/Boxed.cs new file mode 100644 index 0000000000..78484555b8 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Boxed.cs @@ -0,0 +1,62 @@ +// GtkSharp.Boxed.cs - Base class for deriving marshallable structures. +// +// Author: Mike Kestner +// +// Copyright (c) 2001-2002 Mike Kestner +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + +namespace GLib { + + using System; + + [Obsolete] + public class Boxed { + object obj; + IntPtr raw; + + public Boxed (object o) + { + this.obj = o; + } + + public Boxed (IntPtr ptr) + { + this.raw = ptr; + } + + public virtual IntPtr Handle { + get { + return raw; + } + set { + raw = value; + } + } + + public static explicit operator System.IntPtr (Boxed boxed) { + return boxed.Handle; + } + + public virtual object Obj { + get { + return obj; + } + set { + obj = value; + } + } + } +} diff --git a/gstreamer-sharp/glib-sharp/CDeclCallbackAttribute.cs b/gstreamer-sharp/glib-sharp/CDeclCallbackAttribute.cs new file mode 100644 index 0000000000..43897292d0 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/CDeclCallbackAttribute.cs @@ -0,0 +1,30 @@ +// CDeclCallbackAttribute.cs +// +// Author: Mike Kestner +// +// Copyright (c) 2005 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + + [Obsolete ("Use System.Runtime.InteropServices.UnmanagedFunctionPointerAttribute instead")] + public sealed class CDeclCallbackAttribute : Attribute + { + } +} diff --git a/gstreamer-sharp/glib-sharp/ClassInitializerAttribute.cs b/gstreamer-sharp/glib-sharp/ClassInitializerAttribute.cs new file mode 100644 index 0000000000..d38ec83ee8 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/ClassInitializerAttribute.cs @@ -0,0 +1,31 @@ +// ClassInitializerAttribute.cs +// +// Author: Mike Kestner +// +// Copyright (c) 2004 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + + [Obsolete ("Replaced by TypeInitializerAttribute")] + public sealed class ClassInitializerAttribute : Attribute + { + public ClassInitializerAttribute () {} + } +} diff --git a/gstreamer-sharp/glib-sharp/ConnectBeforeAttribute.cs b/gstreamer-sharp/glib-sharp/ConnectBeforeAttribute.cs new file mode 100644 index 0000000000..a306c5d932 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/ConnectBeforeAttribute.cs @@ -0,0 +1,30 @@ +// ConnectBeforeAttribute.cs +// +// Author: Mike Kestner +// +// Copyright (c) 2004 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + + public sealed class ConnectBeforeAttribute : Attribute + { + public ConnectBeforeAttribute () {} + } +} diff --git a/gstreamer-sharp/glib-sharp/DefaultSignalHandlerAttribute.cs b/gstreamer-sharp/glib-sharp/DefaultSignalHandlerAttribute.cs new file mode 100644 index 0000000000..53f42de676 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/DefaultSignalHandlerAttribute.cs @@ -0,0 +1,53 @@ +// DefaultSignalHandlerAttribute.cs +// +// Author: Mike Kestner +// +// Copyright (c) 2003 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + + public sealed class DefaultSignalHandlerAttribute : Attribute + { + private string method; + private System.Type type; + + public DefaultSignalHandlerAttribute () {} + + public string ConnectionMethod + { + get { + return method; + } + set { + method = value; + } + } + + public System.Type Type + { + get { + return type; + } + set { + type = value; + } + } + } +} diff --git a/gstreamer-sharp/glib-sharp/DelegateWrapper.cs b/gstreamer-sharp/glib-sharp/DelegateWrapper.cs new file mode 100644 index 0000000000..841d554fc5 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/DelegateWrapper.cs @@ -0,0 +1,111 @@ +// DelegateWrapper.cs - Delegate wrapper implementation +// +// Authors: +// Rachel Hestilow +// Gonzalo Panigua Javier +// +// Copyright (c) 2002 Rachel Hestilow +// Copyright (c) 2003 Ximian, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.Runtime.InteropServices; + + public class DelegateWrapper + { + // Keys in the hashtable are instances of classes derived from this one. + // Values are each instance's destroy notification delegate + static Hashtable instances = new Hashtable (); + + // This list holds references to wrappers for static + // methods. These will never expire. + static ArrayList static_instances = new ArrayList (); + + static int notify_count = 0; + + // The object 'o' is the object that creates the instance of the DelegateWrapper + // derived class or null if created from a static method. + // Note that the instances will never be disposed if they are created in a static + // method. + [Obsolete ("Callback wrappers should be manually managed for persistence.")] + protected DelegateWrapper (object o) + { + if (o != null) { + // If o is a GObject, we can get + // destroy notification. Otherwise + // no additional references to + // the wrapper are kept. + // FIXME: This should work because + // currently only GObjects store + // callbacks over the long-term + + if (o is GLib.Object) { + AddDestroyNotify ((GLib.Object) o); + } + } else { + // If o is null, we cannot ask for a destroy + // notification, so the wrapper never expires. + + lock (typeof (DelegateWrapper)) { + static_instances.Add (this); + } + } + } + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + private delegate void DestroyNotify (IntPtr data); + + [DllImport("libgobject-2.0-0.dll")] + private static extern void g_object_set_data_full (IntPtr obj, IntPtr name, IntPtr data, DestroyNotify destroy); + + private void AddDestroyNotify (GLib.Object o) { + // This is a bit of an ugly hack. There is no + // way of getting a destroy notification + // explicitly, so we set some data and ask + // for notification when it is removed + + IntPtr name = Marshaller.StringToPtrGStrdup (String.Format ("_GtkSharpDelegateWrapper_{0}", notify_count)); + DestroyNotify destroy = new DestroyNotify (this.OnDestroy); + + g_object_set_data_full (o.Handle, name, IntPtr.Zero, destroy); + Marshaller.Free (name); + lock (typeof (DelegateWrapper)) { + instances[this] = destroy; + notify_count++; + } + } + + // This callback is invoked by GLib to indicate that the + // object that owned the native delegate wrapper no longer + // exists and the instance of the delegate itself is removed from the hash table. + private void OnDestroy (IntPtr data) { + try { + lock (typeof (DelegateWrapper)) { + if (instances.ContainsKey (this)) { + instances.Remove (this); + } + } + } catch (Exception e) { + ExceptionManager.RaiseUnhandledException (e, false); + } + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/DestroyNotify.cs b/gstreamer-sharp/glib-sharp/DestroyNotify.cs new file mode 100644 index 0000000000..f11dbc5dcb --- /dev/null +++ b/gstreamer-sharp/glib-sharp/DestroyNotify.cs @@ -0,0 +1,52 @@ +// GLib.DestroyNotify.cs - internal DestroyNotify helper +// +// Author: Mike Kestner +// +// Copyright (c) 2005 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + public delegate void DestroyNotify (IntPtr data); + + public class DestroyHelper { + + private DestroyHelper () {} + + static void ReleaseGCHandle (IntPtr data) + { + if (data == IntPtr.Zero) + return; + GCHandle gch = (GCHandle) data; + gch.Free (); + } + + static DestroyNotify release_gchandle; + + public static DestroyNotify NotifyHandler { + get { + if (release_gchandle == null) + release_gchandle = new DestroyNotify (ReleaseGCHandle); + return release_gchandle; + } + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/EnumWrapper.cs b/gstreamer-sharp/glib-sharp/EnumWrapper.cs new file mode 100644 index 0000000000..80b4afecc2 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/EnumWrapper.cs @@ -0,0 +1,42 @@ +// EnumWrapper.cs - Class to hold arbitrary glib enums +// +// Author: Rachel Hestilow +// +// Copyright (c) 2002 Rachel Hestilow +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + [Obsolete ("Replaced by direct enum type casts to/from GLib.Value")] + public class EnumWrapper { + int val; + public bool flags; + + public EnumWrapper (int val, bool flags) { + this.val = val; + this.flags = flags; + } + + public static explicit operator int (EnumWrapper wrap) { + return wrap.val; + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/ExceptionManager.cs b/gstreamer-sharp/glib-sharp/ExceptionManager.cs new file mode 100644 index 0000000000..5bc5f54646 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/ExceptionManager.cs @@ -0,0 +1,74 @@ +// GLib.Application.cs - static Application class +// +// Authors: Mike Kestner +// +// Copyright (c) 2007 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + + public delegate void UnhandledExceptionHandler (UnhandledExceptionArgs args); + + public class UnhandledExceptionArgs : System.UnhandledExceptionEventArgs { + + bool exit_app = false; + + public UnhandledExceptionArgs (Exception e, bool is_terminal) : base (e, is_terminal) {} + + public bool ExitApplication { + get { + return exit_app; + } + set { + if (value) + exit_app = value; + } + } + } + + public class ExceptionManager { + + + private ExceptionManager () {} + + public static event UnhandledExceptionHandler UnhandledException; + + public static void RaiseUnhandledException (Exception e, bool is_terminal) + { + if (UnhandledException == null) { + Console.Error.WriteLine ("Exception in Gtk# callback delegate"); + Console.Error.WriteLine (" Note: Applications can use GLib.ExceptionManager.UnhandledException to handle the exception."); + Console.Error.WriteLine (e); + Console.Error.WriteLine (new System.Diagnostics.StackTrace (true)); + Environment.Exit (1); + } + + UnhandledExceptionArgs args = new UnhandledExceptionArgs (e, is_terminal); + try { + UnhandledException (args); + } catch (Exception ex) { + Console.Error.WriteLine (ex); + Environment.Exit (1); + } + + if (is_terminal || args.ExitApplication) + Environment.Exit (1); + } + } +} diff --git a/gstreamer-sharp/glib-sharp/FileUtils.cs b/gstreamer-sharp/glib-sharp/FileUtils.cs new file mode 100644 index 0000000000..53d96ff3a7 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/FileUtils.cs @@ -0,0 +1,48 @@ +// GLib.FileUtils.cs - GFileUtils class implementation +// +// Author: Martin Baulig +// +// Copyright (c) 2002 Ximian, Inc +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Text; + using System.Runtime.InteropServices; + + public class FileUtils + { + [DllImport("libglib-2.0-0.dll")] + extern static bool g_file_get_contents (IntPtr filename, out IntPtr contents, out int length, out IntPtr error); + + public static string GetFileContents (string filename) + { + int length; + IntPtr contents, error; + IntPtr native_filename = Marshaller.StringToPtrGStrdup (filename); + + if (!g_file_get_contents (native_filename, out contents, out length, out error)) + throw new GException (error); + + Marshaller.Free (native_filename); + return Marshaller.Utf8PtrToString (contents); + } + + private FileUtils () {} + } +} diff --git a/gstreamer-sharp/glib-sharp/Format.cs b/gstreamer-sharp/glib-sharp/Format.cs new file mode 100644 index 0000000000..3448466dc9 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Format.cs @@ -0,0 +1,39 @@ +// Format.cs: Wrapper for the g_format code in Glib +// +// Authors: +// Stephane Delcroix (stephane@delcroix.org) +// +// Copyright (c) 2008 Novell, Inc. +// +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + +using System; +using System.Runtime.InteropServices; + +namespace GLib { +#if GTK_SHARP_2_14 + public class Format { + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_format_size_for_display (long size); + + static public string SizeForDisplay (long size) + { + string result = Marshaller.PtrToStringGFree (g_format_size_for_display (size)); + return result; + } + } +#endif +} diff --git a/gstreamer-sharp/glib-sharp/GException.cs b/gstreamer-sharp/glib-sharp/GException.cs new file mode 100644 index 0000000000..a360a69071 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/GException.cs @@ -0,0 +1,57 @@ +// GException.cs : GError handling +// +// Authors: Rachel Hestilow +// +// Copyright (c) 2002 Rachel Hestilow +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + public class GException : Exception + { + IntPtr errptr; + + public GException (IntPtr errptr) : base () + { + this.errptr = errptr; + } + + struct GError { + public int Domain; + public int Code; + public IntPtr Msg; + } + + public override string Message { + get { + GError err = (GError) Marshal.PtrToStructure (errptr, typeof (GError)); + return Marshaller.Utf8PtrToString (err.Msg); + } + } + + [DllImport("libglib-2.0-0.dll")] + static extern void g_clear_error (ref IntPtr errptr); + ~GException () + { + g_clear_error (ref errptr); + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/GInterfaceAdapter.cs b/gstreamer-sharp/glib-sharp/GInterfaceAdapter.cs new file mode 100644 index 0000000000..d76be76a61 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/GInterfaceAdapter.cs @@ -0,0 +1,64 @@ +// GInterfaceAdapter.cs +// +// Author: Mike Kestner +// +// Copyright (c) 2007 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + public delegate void GInterfaceInitHandler (IntPtr iface_ptr, IntPtr data); + + internal delegate void GInterfaceFinalizeHandler (IntPtr iface_ptr, IntPtr data); + + internal struct GInterfaceInfo { + internal GInterfaceInitHandler InitHandler; + internal GInterfaceFinalizeHandler FinalizeHandler; + internal IntPtr Data; + } + + public abstract class GInterfaceAdapter { + + GInterfaceInfo info; + + protected GInterfaceAdapter () + { + } + + protected GInterfaceInitHandler InitHandler { + set { + info.InitHandler = value; + } + } + + public abstract GType GType { get; } + + public abstract IntPtr Handle { get; } + + internal GInterfaceInfo Info { + get { + if (info.Data == IntPtr.Zero) + info.Data = (IntPtr) GCHandle.Alloc (this); + + return info; + } + } + } +} diff --git a/gstreamer-sharp/glib-sharp/GInterfaceAttribute.cs b/gstreamer-sharp/glib-sharp/GInterfaceAttribute.cs new file mode 100644 index 0000000000..58a55d10e6 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/GInterfaceAttribute.cs @@ -0,0 +1,42 @@ +// GInterfaceAttribute.cs +// +// Copyright (c) 2007 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + + [AttributeUsage (AttributeTargets.Interface)] + public sealed class GInterfaceAttribute : Attribute { + Type adapter_type; + + public GInterfaceAttribute (Type adapter_type) + { + this.adapter_type = adapter_type; + } + + public Type AdapterType { + get { + return adapter_type; + } + set { + adapter_type = value; + } + } + } +} diff --git a/gstreamer-sharp/glib-sharp/GString.cs b/gstreamer-sharp/glib-sharp/GString.cs new file mode 100644 index 0000000000..673103f775 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/GString.cs @@ -0,0 +1,60 @@ +// GLib.GString.cs : Marshaler for GStrings +// +// Author: Mike Kestner +// +// Copyright (c) 2004 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + using System; + using System.Runtime.InteropServices; + + public class GString : GLib.IWrapper { + + IntPtr handle; + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_string_free (IntPtr mem, bool free_segments); + + ~GString () + { + g_string_free (handle, true); + } + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_string_new (IntPtr text); + + public GString (string text) + { + IntPtr native_text = Marshaller.StringToPtrGStrdup (text); + handle = g_string_new (native_text); + Marshaller.Free (native_text); + } + + public IntPtr Handle { + get { + return handle; + } + } + + public static string PtrToString (IntPtr ptr) + { + return Marshaller.Utf8PtrToString (ptr); + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/GType.cs b/gstreamer-sharp/glib-sharp/GType.cs new file mode 100644 index 0000000000..c3f09404ad --- /dev/null +++ b/gstreamer-sharp/glib-sharp/GType.cs @@ -0,0 +1,426 @@ +// GLib.Type.cs - GLib GType class implementation +// +// Author: Mike Kestner +// +// Copyright (c) 2003 Mike Kestner +// Copyright (c) 2003 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.IO; + using System.Reflection; + using System.Runtime.InteropServices; + using System.Text; + + public delegate System.Type TypeResolutionHandler (GLib.GType gtype, string gtype_name); + + [StructLayout(LayoutKind.Sequential)] + public struct GType { + + IntPtr val; + + struct GTypeInfo { + public ushort class_size; + IntPtr base_init; + IntPtr base_finalize; + IntPtr class_init; + IntPtr class_finalize; + IntPtr class_data; + public ushort instance_size; + ushort n_preallocs; + IntPtr instance_init; + IntPtr value_table; + } + + struct GTypeQuery { + public IntPtr type; + public IntPtr type_name; + public uint class_size; + public uint instance_size; + } + + public GType (IntPtr val) + { + this.val = val; + } + + public static GType FromName (string native_name) + { + return new GType (g_type_from_name (native_name)); + } + + public static readonly GType Invalid = new GType ((IntPtr) TypeFundamentals.TypeInvalid); + public static readonly GType None = new GType ((IntPtr) TypeFundamentals.TypeNone); + public static readonly GType Interface = new GType ((IntPtr) TypeFundamentals.TypeInterface); + public static readonly GType Char = new GType ((IntPtr) TypeFundamentals.TypeChar); + public static readonly GType UChar = new GType ((IntPtr) TypeFundamentals.TypeUChar); + public static readonly GType Boolean = new GType ((IntPtr) TypeFundamentals.TypeBoolean); + public static readonly GType Int = new GType ((IntPtr) TypeFundamentals.TypeInt); + public static readonly GType UInt = new GType ((IntPtr) TypeFundamentals.TypeUInt); + public static readonly GType Long = new GType ((IntPtr) TypeFundamentals.TypeLong); + public static readonly GType ULong = new GType ((IntPtr) TypeFundamentals.TypeULong); + public static readonly GType Int64 = new GType ((IntPtr) TypeFundamentals.TypeInt64); + public static readonly GType UInt64 = new GType ((IntPtr) TypeFundamentals.TypeUInt64); + public static readonly GType Enum = new GType ((IntPtr) TypeFundamentals.TypeEnum); + public static readonly GType Flags = new GType ((IntPtr) TypeFundamentals.TypeFlags); + public static readonly GType Float = new GType ((IntPtr) TypeFundamentals.TypeFloat); + public static readonly GType Double = new GType ((IntPtr) TypeFundamentals.TypeDouble); + public static readonly GType String = new GType ((IntPtr) TypeFundamentals.TypeString); + public static readonly GType Pointer = new GType ((IntPtr) TypeFundamentals.TypePointer); + public static readonly GType Boxed = new GType ((IntPtr) TypeFundamentals.TypeBoxed); + public static readonly GType Param = new GType ((IntPtr) TypeFundamentals.TypeParam); + public static readonly GType Object = new GType ((IntPtr) TypeFundamentals.TypeObject); + + static Hashtable types = new Hashtable (); + static Hashtable gtypes = new Hashtable (); + + public static void Register (GType native_type, System.Type type) + { + if (native_type != GType.Pointer && native_type != GType.Boxed && native_type != ManagedValue.GType) + types[native_type.Val] = type; + if (type != null) + gtypes[type] = native_type; + } + + static GType () + { + if (!GLib.Thread.Supported) + GLib.Thread.Init (); + + g_type_init (); + + Register (GType.Char, typeof (sbyte)); + Register (GType.UChar, typeof (byte)); + Register (GType.Boolean, typeof (bool)); + Register (GType.Int, typeof (int)); + Register (GType.UInt, typeof (uint)); + Register (GType.Int64, typeof (long)); + Register (GType.UInt64, typeof (ulong)); + Register (GType.Float, typeof (float)); + Register (GType.Double, typeof (double)); + Register (GType.String, typeof (string)); + Register (GType.Pointer, typeof (IntPtr)); + Register (GType.Object, typeof (GLib.Object)); + Register (GType.Pointer, typeof (IntPtr)); + + // One-way mapping + gtypes[typeof (char)] = GType.UInt; + } + + public static explicit operator GType (System.Type type) + { + GType gtype; + + if (gtypes.Contains (type)) + return (GType)gtypes[type]; + + if (type.IsSubclassOf (typeof (GLib.Object))) { + gtype = GLib.Object.LookupGType (type); + Register (gtype, type); + return gtype; + } + + PropertyInfo pi = type.GetProperty ("GType", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy); + if (pi != null) + gtype = (GType) pi.GetValue (null, null); + else if (type.IsDefined (typeof (GTypeAttribute), false)) { + GTypeAttribute gattr = (GTypeAttribute)Attribute.GetCustomAttribute (type, typeof (GTypeAttribute), false); + pi = gattr.WrapperType.GetProperty ("GType", BindingFlags.Public | BindingFlags.Static); + gtype = (GType) pi.GetValue (null, null); + } else if (type.IsSubclassOf (typeof (GLib.Opaque))) + gtype = GType.Pointer; + else + gtype = ManagedValue.GType; + + Register (gtype, type); + return gtype; + } + + static string GetQualifiedName (string cname) + { + for (int i = 1; i < cname.Length; i++) { + if (System.Char.IsUpper (cname[i])) { + if (i == 1 && cname [0] == 'G') + return "GLib." + cname.Substring (1); + else + return cname.Substring (0, i) + "." + cname.Substring (i); + } + } + + return null; + } + + public static explicit operator Type (GType gtype) + { + return LookupType (gtype.Val); + } + + public static void Init () + { + // cctor already calls g_type_init. + } + + public static event TypeResolutionHandler ResolveType; + + public static Type LookupType (IntPtr typeid) + { + if (types.Contains (typeid)) + return (Type)types[typeid]; + + string native_name = Marshaller.Utf8PtrToString (g_type_name (typeid)); + + if (ResolveType != null) { + GLib.GType gt = new GLib.GType (typeid); + + Delegate[] invocation_list = ResolveType.GetInvocationList (); + foreach (Delegate d in invocation_list) { + TypeResolutionHandler handler = (TypeResolutionHandler) d; + System.Type tmp = handler (gt, native_name); + if (tmp != null) { + Register (gt, tmp); + return tmp; + } + } + } + + string type_name = GetQualifiedName (native_name); + if (type_name == null) + return null; + Type result = null; + Assembly[] assemblies = (Assembly[]) AppDomain.CurrentDomain.GetAssemblies ().Clone (); + foreach (Assembly asm in assemblies) { + result = asm.GetType (type_name); + if (result != null) + break; + } + + if (result == null) { + // Because of lazy loading of references, it's possible the type's assembly + // needs to be loaded. We will look for it by name in the references of + // the currently loaded assemblies. Hopefully a recursive traversal is + // not needed. We avoid one for now because of problems experienced + // in a patch from bug #400595, and a desire to keep memory usage low + // by avoiding a complete loading of all dependent assemblies. + string ns = type_name.Substring (0, type_name.LastIndexOf ('.')); + string asm_name = ns.ToLower ().Replace ('.', '-') + "-sharp"; + foreach (Assembly asm in assemblies) { + foreach (AssemblyName ref_name in asm.GetReferencedAssemblies ()) { + if (ref_name.Name != asm_name) + continue; + string asm_dir = Path.GetDirectoryName (asm.Location); + try { + Assembly ref_asm; + if (File.Exists (Path.Combine (asm_dir, ref_name.Name + ".dll"))) + ref_asm = Assembly.LoadFrom (Path.Combine (asm_dir, ref_name.Name + ".dll")); + else + ref_asm = Assembly.Load (ref_name); + result = ref_asm.GetType (type_name); + if (result != null) + break; + } catch (Exception) { + /* Failure to load a referenced assembly is not an error */ + } + } + if (result != null) + break; + } + } + + Register (new GType (typeid), result); + return result; + } + + public IntPtr Val { + get { return val; } + } + + public static bool operator == (GType a, GType b) + { + return a.Val == b.Val; + } + + public static bool operator != (GType a, GType b) + { + return a.Val != b.Val; + } + + public override bool Equals (object o) + { + if (!(o is GType)) + return false; + + return ((GType) o) == this; + } + + public override int GetHashCode () + { + return val.GetHashCode (); + } + + public override string ToString () + { + return Marshaller.Utf8PtrToString (g_type_name (val)); + } + + public IntPtr ClassPtr { + get { + IntPtr klass = g_type_class_peek (val); + if (klass == IntPtr.Zero) + klass = g_type_class_ref (val); + return klass; + } + } + + public GType BaseType { + get { + IntPtr parent = g_type_parent (this.Val); + if (parent == IntPtr.Zero) + return GType.None; + else + return new GType (parent); + } + } + + public GType ThresholdType { + get { + GLib.GType curr_type = this; + while (curr_type.ToString ().StartsWith ("__gtksharp_")) { + curr_type = curr_type.BaseType; + } + return curr_type; + } + } + + public uint ClassSize { + get { + GTypeQuery query; + g_type_query (this.Val, out query); + return query.class_size; + } + } + + internal void EnsureClass () + { + if (g_type_class_peek (val) == IntPtr.Zero) + g_type_class_ref (val); + } + + static int type_uid; + static string BuildEscapedName (System.Type t) + { + string qn = t.FullName; + // Just a random guess + StringBuilder sb = new StringBuilder (20 + qn.Length); + sb.Append ("__gtksharp_"); + sb.Append (type_uid++); + sb.Append ("_"); + foreach (char c in qn) { + if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) + sb.Append (c); + else if (c == '.') + sb.Append ('_'); + else if ((uint) c <= byte.MaxValue) { + sb.Append ('+'); + sb.Append (((byte) c).ToString ("x2")); + } else { + sb.Append ('-'); + sb.Append (((uint) c).ToString ("x4")); + } + } + return sb.ToString (); + } + + internal static GType RegisterGObjectType (System.Type t) + { + GType parent_gtype = LookupGObjectType (t.BaseType); + string name = BuildEscapedName (t); + IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name); + GTypeQuery query; + g_type_query (parent_gtype.Val, out query); + GTypeInfo info = new GTypeInfo (); + info.class_size = (ushort) query.class_size; + info.instance_size = (ushort) query.instance_size; + GType gtype = new GType (g_type_register_static (parent_gtype.Val, native_name, ref info, 0)); + GLib.Marshaller.Free (native_name); + Register (gtype, t); + return gtype; + } + + internal static GType LookupGObjectType (System.Type t) + { + if (gtypes.Contains (t)) + return (GType) gtypes [t]; + + PropertyInfo pi = t.GetProperty ("GType", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public); + if (pi != null) + return (GType) pi.GetValue (null, null); + + return GLib.Object.RegisterGType (t); + } + + internal static IntPtr ValFromInstancePtr (IntPtr handle) + { + if (handle == IntPtr.Zero) + return IntPtr.Zero; + + // First field of instance is a GTypeClass*. + IntPtr klass = Marshal.ReadIntPtr (handle); + // First field of GTypeClass is a GType. + return Marshal.ReadIntPtr (klass); + } + + internal static bool Is (IntPtr type, GType is_a_type) + { + return g_type_is_a (type, is_a_type.Val); + } + + public bool IsInstance (IntPtr raw) + { + return GType.Is (ValFromInstancePtr (raw), this); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_type_class_peek (IntPtr gtype); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_type_class_ref (IntPtr gtype); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_type_from_name (string name); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_type_init (); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_type_name (IntPtr raw); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_type_parent (IntPtr type); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_type_query (IntPtr type, out GTypeQuery query); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_type_register_static (IntPtr parent, IntPtr name, ref GTypeInfo info, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern bool g_type_is_a (IntPtr type, IntPtr is_a_type); + } +} diff --git a/gstreamer-sharp/glib-sharp/GTypeAttribute.cs b/gstreamer-sharp/glib-sharp/GTypeAttribute.cs new file mode 100644 index 0000000000..7a2e14f00e --- /dev/null +++ b/gstreamer-sharp/glib-sharp/GTypeAttribute.cs @@ -0,0 +1,42 @@ +// GTypeAttribute.cs +// +// Copyright (c) 2005 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + + [AttributeUsage (AttributeTargets.Enum)] + public sealed class GTypeAttribute : Attribute { + Type wrapper_type; + + public GTypeAttribute (Type wrapper_type) + { + this.wrapper_type = wrapper_type; + } + + public Type WrapperType { + get { + return wrapper_type; + } + set { + wrapper_type = value; + } + } + } +} diff --git a/gstreamer-sharp/glib-sharp/Global.cs b/gstreamer-sharp/glib-sharp/Global.cs new file mode 100644 index 0000000000..fb7f3eb0ef --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Global.cs @@ -0,0 +1,68 @@ +// GLib.Global.cs - Global glib properties and methods. +// +// Author: Andres G. Aragoneses +// +// Copyright (c) 2008 Novell, Inc +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Text; + using System.Runtime.InteropServices; + + public class Global + { + + //this is a static class + private Global () {} + + public static string ProgramName { + get { + return GLib.Marshaller.PtrToStringGFree(g_get_prgname()); + } + set { + IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (value); + g_set_prgname (native_name); + GLib.Marshaller.Free (native_name); + } + } + + [DllImport("libglib-2.0-0.dll")] + static extern void g_set_prgname (IntPtr name); + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_get_prgname (); + + public static string ApplicationName { + get { + return GLib.Marshaller.PtrToStringGFree(g_get_application_name()); + } + set { + IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (value); + g_set_application_name (native_name); + GLib.Marshaller.Free (native_name); + } + } + + [DllImport("libglib-2.0-0.dll")] + static extern void g_set_application_name (IntPtr name); + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_get_application_name (); + } +} diff --git a/gstreamer-sharp/glib-sharp/IOChannel.cs b/gstreamer-sharp/glib-sharp/IOChannel.cs new file mode 100644 index 0000000000..05ec27140d --- /dev/null +++ b/gstreamer-sharp/glib-sharp/IOChannel.cs @@ -0,0 +1,469 @@ +// glib/IOChannel.cs : IOChannel API wrapper +// +// Author: Mike Kestner +// +// Copyright (c) 2007 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLibSharp { + + using System; + using System.Runtime.InteropServices; + using GLib; + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate bool IOFuncNative(IntPtr source, int condition, IntPtr data); + + internal class IOFuncWrapper { + + IOFunc managed; + + public IOFuncNative NativeDelegate; + + public IOFuncWrapper (IOFunc managed) + { + this.managed = managed; + NativeDelegate = new IOFuncNative (NativeCallback); + } + bool NativeCallback (IntPtr source, int condition, IntPtr data) + { + try { + return managed (IOChannel.FromHandle (source), (IOCondition) condition); + } catch (Exception e) { + ExceptionManager.RaiseUnhandledException (e, false); + return false; + } + } + } +} + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + using GLibSharp; + + public class IOChannel : IDisposable, IWrapper { + + IntPtr handle; + + private IOChannel(IntPtr handle) + { + this.handle = handle; + } + + public IOChannel (int fd) : this (g_io_channel_unix_new (fd)) {} + + public IOChannel (string filename, string mode) + { + IntPtr native_filename = Marshaller.StringToPtrGStrdup (filename); + IntPtr native_mode = Marshaller.StringToPtrGStrdup (mode); + IntPtr error; + handle = g_io_channel_new_file(native_filename, native_mode, out error); + Marshaller.Free (native_filename); + Marshaller.Free (native_mode); + if (error != IntPtr.Zero) throw new GException (error); + } + + public IOCondition BufferCondition + { + get { + return (IOCondition) g_io_channel_get_buffer_condition (Handle); + } + } + + public bool Buffered + { + get { + return g_io_channel_get_buffered (Handle); + } + set { + g_io_channel_set_buffered (Handle, value); + } + } + + public ulong BufferSize + { + get { + return (ulong) g_io_channel_get_buffer_size (Handle); + } + set { + g_io_channel_set_buffer_size (Handle, new UIntPtr (value)); + } + } + + public bool CloseOnUnref + { + get { + return g_io_channel_get_close_on_unref (Handle); + } + set { + g_io_channel_set_close_on_unref (Handle, value); + } + } + + public string Encoding + { + get { + return Marshaller.Utf8PtrToString (g_io_channel_get_encoding (Handle)); + } + set { + IntPtr native_encoding = Marshaller.StringToPtrGStrdup (value); + IntPtr error; + g_io_channel_set_encoding (Handle, native_encoding, out error); + Marshaller.Free (native_encoding); + if (error != IntPtr.Zero) throw new GException (error); + } + } + + public IOFlags Flags + { + get { + return (IOFlags) g_io_channel_get_flags(Handle); + } + set { + IntPtr error; + g_io_channel_set_flags(Handle, (int) value, out error); + if (error != IntPtr.Zero) throw new GException (error); + } + } + + public char[] LineTerminator { + get { + int length; + IntPtr raw = g_io_channel_get_line_term (Handle, out length); + if (length == -1) + return Marshaller.Utf8PtrToString (raw).ToCharArray (); + byte[] buffer = new byte [length]; + return System.Text.Encoding.UTF8.GetChars (buffer); + } + set { + byte[] buffer = System.Text.Encoding.UTF8.GetBytes (value); + g_io_channel_set_line_term (Handle, buffer, buffer.Length); + } + } + + public IntPtr Handle { + get { + return handle; + } + } + + public int UnixFd { + get { + return g_io_channel_unix_get_fd (Handle); + } + } + + protected void Init () + { + g_io_channel_init (Handle); + } + + public void Dispose () + { + g_io_channel_unref (Handle); + } + + public uint AddWatch (int priority, IOCondition condition, IOFunc func) + { + IOFuncWrapper func_wrapper = null; + IntPtr user_data = IntPtr.Zero; + DestroyNotify notify = null; + if (func != null) { + func_wrapper = new IOFuncWrapper (func); + user_data = (IntPtr) GCHandle.Alloc (func_wrapper); + notify = DestroyHelper.NotifyHandler; + } + return g_io_add_watch_full (Handle, priority, (int) condition, func_wrapper.NativeDelegate, user_data, notify); + } + + public IOStatus Flush () + { + IntPtr error; + IOStatus ret = (IOStatus) g_io_channel_flush (Handle, out error); + if (error != IntPtr.Zero) throw new GException (error); + return ret; + } + + public IOStatus ReadChars (byte[] buf, out ulong bytes_read) + { + UIntPtr native_bytes_read; + IntPtr error; + IOStatus ret = (IOStatus) g_io_channel_read_chars (Handle, buf, new UIntPtr ((ulong) buf.Length), out native_bytes_read, out error); + bytes_read = (ulong) native_bytes_read; + if (error != IntPtr.Zero) throw new GException (error); + return ret; + } + + public IOStatus ReadLine (out string str_return) + { + ulong dump; + return ReadLine (out str_return, out dump); + } + + public IOStatus ReadLine (out string str_return, out ulong terminator_pos) + { + IntPtr native_string; + UIntPtr native_terminator_pos; + IntPtr error; + IOStatus ret = (IOStatus) g_io_channel_read_line (Handle, out native_string, IntPtr.Zero, out native_terminator_pos, out error); + terminator_pos = (ulong) native_terminator_pos; + str_return = null; + if (ret == IOStatus.Normal) + str_return = Marshaller.PtrToStringGFree (native_string); + if (error != IntPtr.Zero) throw new GException (error); + return ret; + } + + public IOStatus ReadToEnd (out string str_return) + { + IntPtr native_str; + UIntPtr native_length; + IntPtr error; + IOStatus ret = (IOStatus) g_io_channel_read_to_end (Handle, out native_str, out native_length, out error); + str_return = null; + if (ret == IOStatus.Normal) { + byte[] buffer = new byte [(ulong) native_length]; + Marshal.Copy (native_str, buffer, 0, (int)(ulong) native_length); + str_return = System.Text.Encoding.UTF8.GetString (buffer); + } + Marshaller.Free (native_str); + if (error != IntPtr.Zero) throw new GException (error); + return ret; + } + + public IOStatus ReadUnichar (out uint thechar) + { + IntPtr error; + IOStatus ret = (IOStatus) g_io_channel_read_unichar (Handle, out thechar, out error); + if (error != IntPtr.Zero) throw new GException (error); + return ret; + } + + public IOStatus SeekPosition (long offset, SeekType type) + { + IntPtr error; + IOStatus ret = (IOStatus) g_io_channel_seek_position (Handle, offset, (int) type, out error); + if (error != IntPtr.Zero) throw new GException (error); + return ret; + } + + public IOStatus Shutdown (bool flush) + { + IntPtr error; + IOStatus ret = (IOStatus) g_io_channel_shutdown (Handle, flush, out error); + if (error != IntPtr.Zero) throw new GException (error); + return ret; + } + + public IOStatus WriteChars (string str, out string remainder) + { + ulong written; + System.Text.Encoding enc = System.Text.Encoding.UTF8; + byte[] buffer = enc.GetBytes (str); + IOStatus ret = WriteChars (buffer, out written); + remainder = null; + if ((int) written == buffer.Length) + return ret; + int count = buffer.Length - (int) written; + byte[] rem = new byte [count]; + Array.Copy (buffer, (int) written, rem, 0, count); + remainder = enc.GetString (rem); + return ret; + } + + public IOStatus WriteChars (byte[] buf, out ulong bytes_written) + { + UIntPtr native_bytes_written; + IntPtr error; + IOStatus ret = (IOStatus) g_io_channel_write_chars (Handle, buf, new IntPtr (buf.Length), out native_bytes_written, out error); + bytes_written = (ulong) native_bytes_written; + if (error != IntPtr.Zero) throw new GException (error); + return ret; + } + + public IOStatus WriteUnichar (uint thechar) + { + IntPtr error; + IOStatus ret = (IOStatus) g_io_channel_write_unichar (Handle, thechar, out error); + if (error != IntPtr.Zero) throw new GException (error); + return ret; + } + + public static IOChannel FromHandle (IntPtr handle) + { + if (handle == IntPtr.Zero) + return null; + + g_io_channel_ref (handle); + return new IOChannel (handle); + } + + public static IOChannelError ErrorFromErrno (int en) + { + return (IOChannelError) g_io_channel_error_from_errno (en); + } + + const string libname = "libglib-2.0-0.dll"; + + [DllImport (libname)] + static extern IntPtr g_io_channel_unix_new (int fd); + + [DllImport (libname)] + static extern IntPtr g_io_channel_new_file (IntPtr filename, IntPtr mode, out IntPtr error); + + [DllImport (libname)] + static extern int g_io_channel_error_quark (); + + [DllImport(libname)] + static extern int g_io_channel_error_from_errno (int en); + + [DllImport (libname)] + static extern int g_io_channel_flush (IntPtr raw, out IntPtr error); + + [DllImport (libname)] + static extern void g_io_channel_init (IntPtr raw); + + [DllImport (libname)] + static extern int g_io_channel_read_chars (IntPtr raw, byte[] buf, UIntPtr count, out UIntPtr bytes_read, out IntPtr error); + + [DllImport (libname)] + static extern int g_io_channel_read_line (IntPtr raw, out IntPtr str_return, IntPtr length, out UIntPtr terminator_pos, out IntPtr error); + + [DllImport (libname)] + static extern int g_io_channel_read_to_end (IntPtr raw, out IntPtr str_return, out UIntPtr length, out IntPtr error); + + [DllImport (libname)] + static extern int g_io_channel_read_unichar (IntPtr raw, out uint thechar, out IntPtr error); + + [DllImport (libname)] + static extern int g_io_channel_seek_position (IntPtr raw, long offset, int type, out IntPtr error); + + [DllImport (libname)] + static extern int g_io_channel_shutdown (IntPtr raw, bool flush, out IntPtr err); + + [DllImport (libname)] + static extern int g_io_channel_write_chars (IntPtr raw, byte[] buf, IntPtr count, out UIntPtr bytes_written, out IntPtr error); + + [DllImport (libname)] + static extern int g_io_channel_write_unichar (IntPtr raw, uint thechar, out IntPtr error); + + [DllImport (libname)] + static extern int g_io_channel_get_buffer_condition (IntPtr raw); + + [DllImport (libname)] + static extern bool g_io_channel_get_buffered (IntPtr raw); + + [DllImport (libname)] + static extern void g_io_channel_set_buffered (IntPtr raw, bool buffered); + + [DllImport (libname)] + static extern UIntPtr g_io_channel_get_buffer_size (IntPtr raw); + + [DllImport (libname)] + static extern void g_io_channel_set_buffer_size (IntPtr raw, UIntPtr size); + + [DllImport (libname)] + static extern bool g_io_channel_get_close_on_unref (IntPtr raw); + + [DllImport (libname)] + static extern void g_io_channel_set_close_on_unref (IntPtr raw, bool do_close); + + [DllImport (libname)] + static extern IntPtr g_io_channel_get_encoding (IntPtr raw); + + [DllImport (libname)] + static extern int g_io_channel_set_encoding (IntPtr raw, IntPtr encoding, out IntPtr error); + + [DllImport (libname)] + static extern int g_io_channel_get_flags (IntPtr raw); + + [DllImport (libname)] + static extern int g_io_channel_set_flags (IntPtr raw, int flags, out IntPtr error); + + [DllImport (libname)] + static extern IntPtr g_io_channel_get_line_term (IntPtr raw, out int length); + + [DllImport (libname)] + static extern void g_io_channel_set_line_term (IntPtr raw, byte[] term, int length); + + [DllImport (libname)] + static extern int g_io_channel_unix_get_fd (IntPtr raw); + + [DllImport (libname)] + static extern IntPtr g_io_channel_ref (IntPtr raw); + + [DllImport (libname)] + static extern void g_io_channel_unref (IntPtr raw); + + [DllImport (libname)] + static extern uint g_io_add_watch_full (IntPtr raw, int priority, int condition, IOFuncNative func, IntPtr user_data, DestroyNotify notify); + + [DllImport (libname)] + static extern IntPtr g_io_create_watch (IntPtr raw, int condition); + } + + public delegate bool IOFunc (IOChannel source, IOCondition condition); + + public enum IOChannelError { + FileTooBig, + Inval, + IO, + IsDir, + NoSpace, + Nxio, + Overflow, + Pipe, + Failed, + } + + [Flags] + public enum IOCondition { + In = 1 << 0, + Out = 1 << 2, + Pri = 1 << 1, + Err = 1 << 3, + Hup = 1 << 4, + Nval = 1 << 5, + } + + [Flags] + public enum IOFlags { + Append = 1 << 0, + Nonblock = 1 << 1, + IsReadable = 1 << 2, + IsWriteable = 1 << 3, + IsSeekable = 1 << 4, + Mask = 1 << 5- 1, + GetMask = Mask, + SetMask = Append | Nonblock, + } + + public enum IOStatus { + Error, + Normal, + Eof, + Again, + } + + public enum SeekType { + Cur, + Set, + End, + } +} diff --git a/gstreamer-sharp/glib-sharp/IWrapper.cs b/gstreamer-sharp/glib-sharp/IWrapper.cs new file mode 100644 index 0000000000..db919bd831 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/IWrapper.cs @@ -0,0 +1,30 @@ +// IWrapper.cs - Common code for GInterfaces and GObjects +// +// Author: Rachel Hestilow +// +// Copyright (c) 2002 Rachel Hestilow +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib +{ + using System; + + public interface IWrapper + { + IntPtr Handle { get; } + } +} diff --git a/gstreamer-sharp/glib-sharp/Idle.cs b/gstreamer-sharp/glib-sharp/Idle.cs new file mode 100644 index 0000000000..589eb86868 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Idle.cs @@ -0,0 +1,125 @@ +// GLib.Idle.cs - Idle class implementation +// +// Author(s): +// Mike Kestner +// Rachel Hestilow +// Stephane Delcroix +// +// Copyright (c) 2002 Mike Kestner +// Copyright (c) Rachel Hestilow +// Copyright (c) 2009 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.Runtime.InteropServices; + + public delegate bool IdleHandler (); + + public class Idle { + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate bool IdleHandlerInternal (); + + + internal class IdleProxy : SourceProxy { + public IdleProxy (IdleHandler real) + { + real_handler = real; + proxy_handler = new IdleHandlerInternal (Handler); + } + + public bool Handler () + { + try { + IdleHandler idle_handler = (IdleHandler) real_handler; + + bool cont = idle_handler (); + if (!cont) + Remove (); + return cont; + } catch (Exception e) { + ExceptionManager.RaiseUnhandledException (e, false); + } + return false; + } + } + + private Idle () + { + } + + [DllImport("libglib-2.0-0.dll")] + static extern uint g_idle_add (IdleHandlerInternal d, IntPtr data); + + public static uint Add (IdleHandler hndlr) + { + IdleProxy p = new IdleProxy (hndlr); + p.ID = g_idle_add ((IdleHandlerInternal) p.proxy_handler, IntPtr.Zero); + lock (Source.source_handlers) + Source.source_handlers [p.ID] = p; + + return p.ID; + } + + [DllImport("libglib-2.0-0.dll")] + static extern uint g_idle_add_full (int priority, IdleHandlerInternal d, IntPtr data, DestroyNotify notify); + + public static uint Add (IdleHandler hndlr, Priority priority) + { + IdleProxy p = new IdleProxy (hndlr); + p.ID = g_idle_add_full ((int)priority, (IdleHandlerInternal)p.proxy_handler, IntPtr.Zero, null); + lock (Source.source_handlers) + Source.source_handlers [p.ID] = p; + + return p.ID; + } + + [DllImport("libglib-2.0-0.dll")] + static extern bool g_source_remove_by_funcs_user_data (Delegate d, IntPtr data); + + public static void Remove (uint id) + { + Source.Remove (id); + } + + public static bool Remove (IdleHandler hndlr) + { + bool result = false; + ArrayList keys = new ArrayList (); + + lock (Source.source_handlers) { + foreach (uint code in Source.source_handlers.Keys) { + IdleProxy p = Source.source_handlers [code] as IdleProxy; + + if (p != null && p.real_handler == hndlr) { + keys.Add (code); + result = g_source_remove_by_funcs_user_data (p.proxy_handler, IntPtr.Zero); + } + } + + foreach (object key in keys) + Source.source_handlers.Remove (key); + } + + return result; + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/IgnoreClassInitializersAttribute.cs b/gstreamer-sharp/glib-sharp/IgnoreClassInitializersAttribute.cs new file mode 100644 index 0000000000..1dada10f40 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/IgnoreClassInitializersAttribute.cs @@ -0,0 +1,31 @@ +// IgnoreClassInitializersAttribute.cs +// +// Author: Mike Kestner +// +// Copyright (c) 2007 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + + [AttributeUsage (AttributeTargets.Assembly)] + public sealed class IgnoreClassInitializersAttribute : Attribute + { + public IgnoreClassInitializersAttribute () {} + } +} diff --git a/gstreamer-sharp/glib-sharp/InitiallyUnowned.cs b/gstreamer-sharp/glib-sharp/InitiallyUnowned.cs new file mode 100644 index 0000000000..784fa04ca2 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/InitiallyUnowned.cs @@ -0,0 +1,46 @@ +// InitiallyUnowned.cs - GInitiallyUnowned class wrapper implementation +// +// Authors: Mike Kestner +// +// Copyright (c) 2004-2005 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + +#if GTK_SHARP_2_10 + +namespace GLib { + + using System; + using System.Collections; + using System.ComponentModel; + using System.Runtime.InteropServices; + + public class InitiallyUnowned : Object { + + protected InitiallyUnowned (IntPtr raw) : base (raw) {} + + [Obsolete] + protected InitiallyUnowned (GType gtype) : base (gtype) {} + + public new static GLib.GType GType { + get { + return GType.Object; + } + } + + } +} + +#endif diff --git a/gstreamer-sharp/glib-sharp/List.cs b/gstreamer-sharp/glib-sharp/List.cs new file mode 100644 index 0000000000..eefb21a2e6 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/List.cs @@ -0,0 +1,97 @@ +// List.cs - GList class wrapper implementation +// +// Authors: Mike Kestner +// +// Copyright (c) 2002 Mike Kestner +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + public class List : ListBase { + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_list_copy (IntPtr l); + + public override object Clone () + { + return new List (g_list_copy (Handle)); + } + + [DllImport("libglib-2.0-0.dll")] + static extern int g_list_length (IntPtr l); + + internal override int Length (IntPtr list) + { + return g_list_length (list); + } + + [DllImport("libglib-2.0-0.dll")] + static extern void g_list_free(IntPtr l); + + internal override void Free (IntPtr list) + { + if (list != IntPtr.Zero) + g_list_free (list); + } + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_list_append (IntPtr l, IntPtr raw); + + internal override IntPtr Append (IntPtr list, IntPtr raw) + { + return g_list_append (list, raw); + } + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_list_prepend (IntPtr l, IntPtr raw); + + internal override IntPtr Prepend (IntPtr list, IntPtr raw) + { + return g_list_prepend (list, raw); + } + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_list_nth_data (IntPtr l, uint n); + + internal override IntPtr NthData (uint n) + { + return g_list_nth_data (Handle, n); + } + + public List (IntPtr raw) : this (raw, null) {} + + public List (System.Type element_type) : this (IntPtr.Zero, element_type) {} + + public List (IntPtr raw, System.Type element_type) : this (raw, element_type, false, false) {} + + public List (IntPtr raw, System.Type element_type, bool owned, bool elements_owned) : base (raw, element_type, owned, elements_owned) {} + + public List (object[] elements, System.Type element_type, bool owned, bool elements_owned) : this (IntPtr.Zero, element_type, owned, elements_owned) + { + foreach (object o in elements) + Append (o); + } + public List (Array elements, System.Type element_type, bool owned, bool elements_owned) : this (IntPtr.Zero, element_type, owned, elements_owned) + { + foreach (object o in elements) + Append (o); + } + } +} diff --git a/gstreamer-sharp/glib-sharp/ListBase.cs b/gstreamer-sharp/glib-sharp/ListBase.cs new file mode 100644 index 0000000000..7cc0fe422b --- /dev/null +++ b/gstreamer-sharp/glib-sharp/ListBase.cs @@ -0,0 +1,279 @@ +// ListBase.cs - List base class implementation +// +// Authors: Mike Kestner +// +// Copyright (c) 2002 Mike Kestner +// Copyright (c) 2005 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.Runtime.InteropServices; + + public abstract class ListBase : IDisposable, ICollection, GLib.IWrapper, ICloneable { + + private IntPtr list_ptr = IntPtr.Zero; + private int length = -1; + private bool managed = false; + internal bool elements_owned = false; + protected System.Type element_type = null; + + abstract internal IntPtr NthData (uint index); + abstract internal int Length (IntPtr list); + abstract internal void Free (IntPtr list); + abstract internal IntPtr Append (IntPtr current, IntPtr raw); + abstract internal IntPtr Prepend (IntPtr current, IntPtr raw); + + internal ListBase (IntPtr list, System.Type element_type, bool owned, bool elements_owned) + { + list_ptr = list; + this.element_type = element_type; + managed = owned; + this.elements_owned = elements_owned; + } + + ~ListBase () + { + Dispose (false); + } + + [Obsolete ("Replaced by owned parameter on ctor.")] + public bool Managed { + set { managed = value; } + } + + public IntPtr Handle { + get { + return list_ptr; + } + } + + public void Append (IntPtr raw) + { + list_ptr = Append (list_ptr, raw); + } + + public void Append (string item) + { + this.Append (Marshaller.StringToPtrGStrdup (item)); + } + + public void Append (object item) + { + this.Append (AllocNativeElement (item)); + } + + public void Prepend (IntPtr raw) + { + list_ptr = Prepend (list_ptr, raw); + } + + // ICollection + public int Count { + get { + if (length == -1) + length = Length (list_ptr); + return length; + } + } + + public object this [int index] { + get { + IntPtr data = NthData ((uint) index); + object ret = null; + ret = DataMarshal (data); + return ret; + } + } + + // Synchronization could be tricky here. Hmm. + public bool IsSynchronized { + get { return false; } + } + + public object SyncRoot { + get { return null; } + } + + public void CopyTo (Array array, int index) + { + object[] orig = new object[Count]; + int i = 0; + foreach (object o in this) + orig [i++] = o; + + orig.CopyTo (array, index); + } + + public class FilenameString { + private FilenameString () {} + } + + IntPtr AllocNativeElement (object element) + { + if (element_type == null) { + if (element is IWrapper) + return (element as IWrapper).Handle; + else + return (IntPtr) GCHandle.Alloc (element); + } else { + if (element_type == typeof (string)) + return Marshaller.StringToPtrGStrdup (element as string); + else if (element_type == typeof (FilenameString)) + return Marshaller.StringToFilenamePtr (element as string); + else if (element_type == typeof (IntPtr)) + return (IntPtr) GCHandle.Alloc (element); + else if (typeof (IWrapper).IsAssignableFrom (element_type)) + return (element as IWrapper).Handle; + else if (element_type == typeof (int)) + return new IntPtr ((int) element); + else if (element_type.IsValueType) + return Marshaller.StructureToPtrAlloc (element); + } + return IntPtr.Zero; + } + + internal object DataMarshal (IntPtr data) + { + object ret = null; + if (element_type != null) { + if (element_type == typeof (string)) + ret = Marshaller.Utf8PtrToString (data); + else if (element_type == typeof (FilenameString)) + ret = Marshaller.FilenamePtrToString (data); + else if (element_type == typeof (IntPtr)) + ret = data; + else if (element_type.IsSubclassOf (typeof (GLib.Object))) + ret = GLib.Object.GetObject (data, false); + else if (element_type.IsSubclassOf (typeof (GLib.Opaque))) + ret = GLib.Opaque.GetOpaque (data, element_type, elements_owned); + else if (element_type == typeof (int)) + ret = (int) data; + else if (element_type.IsValueType) + ret = Marshal.PtrToStructure (data, element_type); + else if (element_type.IsInterface) { + Type adapter_type = element_type.Assembly.GetType (element_type.FullName + "Adapter"); + System.Reflection.MethodInfo method = adapter_type.GetMethod ("GetObject", new Type[] {typeof(IntPtr), typeof(bool)}); + ret = method.Invoke (null, new object[] {data, false}); + } else + ret = Activator.CreateInstance (element_type, new object[] {data}); + + } else if (Object.IsObject (data)) + ret = GLib.Object.GetObject (data, false); + + return ret; + } + + [DllImport ("libglib-2.0-0.dll")] + static extern void g_free (IntPtr item); + + [DllImport ("libgobject-2.0-0.dll")] + static extern void g_object_unref (IntPtr item); + + public void Empty () + { + if (elements_owned) + for (uint i = 0; i < Count; i++) + if (typeof (GLib.Object).IsAssignableFrom (element_type)) + g_object_unref (NthData (i)); + else if (typeof (GLib.Opaque).IsAssignableFrom (element_type)) + GLib.Opaque.GetOpaque (NthData (i), element_type, true).Dispose (); + else + g_free (NthData (i)); + + if (managed) + FreeList (); + } + + IntPtr GetData (IntPtr current) + { + // data field is at offset 0 for GList and GSList + return Marshal.ReadIntPtr (current); + } + + IntPtr Next (IntPtr current) + { + // next field follows gpointer data field for GList and GSList + return Marshal.ReadIntPtr (current, IntPtr.Size); + } + + private class ListEnumerator : IEnumerator + { + private IntPtr current = IntPtr.Zero; + private ListBase list; + + public ListEnumerator (ListBase list) + { + this.list = list; + } + + public object Current { + get { + IntPtr data = list.GetData (current); + object ret = null; + ret = list.DataMarshal (data); + return ret; + } + } + + public bool MoveNext () + { + if (current == IntPtr.Zero) + current = list.list_ptr; + else + current = list.Next (current); + return (current != IntPtr.Zero); + } + + public void Reset () + { + current = IntPtr.Zero; + } + } + + // IEnumerable + public IEnumerator GetEnumerator () + { + return new ListEnumerator (this); + } + + // IDisposable + public void Dispose () + { + Dispose (true); + GC.SuppressFinalize (this); + } + + protected virtual void Dispose (bool disposing) + { + Empty (); + } + + void FreeList () + { + if (list_ptr != IntPtr.Zero) + Free (list_ptr); + list_ptr = IntPtr.Zero; + length = -1; + } + + // ICloneable + abstract public object Clone (); + } +} diff --git a/gstreamer-sharp/glib-sharp/Log.cs b/gstreamer-sharp/glib-sharp/Log.cs new file mode 100644 index 0000000000..b3d20e12de --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Log.cs @@ -0,0 +1,191 @@ +// Log.cs - Wrapper for message logging functions +// +// Authors: +// Gonzalo Paniagua Javier (gonzalo@ximian.com) +// +// +// Copyright (c) 2002 Gonzalo Paniagua +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + +// + +namespace GLib { + + using System; + using System.Collections; + using System.Runtime.InteropServices; + + public delegate void LogFunc (string log_domain, LogLevelFlags log_level, string message); + + public delegate void PrintFunc (string message); + + [Flags] + public enum LogLevelFlags : int + { + /* log flags */ + FlagRecursion = 1 << 0, + FlagFatal = 1 << 1, + + /* GLib log levels */ + Error = 1 << 2, /* always fatal */ + Critical = 1 << 3, + Warning = 1 << 4, + Message = 1 << 5, + Info = 1 << 6, + Debug = 1 << 7, + + /* Convenience values */ + AllButFatal = 253, + AllButRecursion = 254, + All = 255, + + FlagMask = 3, + LevelMask = unchecked ((int) 0xFFFFFFFC) + } + + public class Log { + + static Hashtable handlers; + + static void EnsureHash () + { + if (handlers == null) + handlers = new Hashtable (); + } + + [DllImport("libglib-2.0-0.dll")] + static extern void g_logv (IntPtr log_domain, LogLevelFlags flags, IntPtr message); + + public void WriteLog (string logDomain, LogLevelFlags flags, string format, params object [] args) + { + IntPtr ndom = Marshaller.StringToPtrGStrdup (logDomain); + IntPtr nmessage = Marshaller.StringToPtrGStrdup (String.Format (format, args)); + g_logv (ndom, flags, nmessage); + Marshaller.Free (ndom); + Marshaller.Free (nmessage); + } + + [DllImport("libglib-2.0-0.dll")] + static extern uint g_log_set_handler (IntPtr log_domain, LogLevelFlags flags, LogFunc log_func, IntPtr user_data); + + public static uint SetLogHandler (string logDomain, LogLevelFlags flags, LogFunc logFunc) + { + IntPtr ndom = Marshaller.StringToPtrGStrdup (logDomain); + uint result = g_log_set_handler (ndom, flags, logFunc, IntPtr.Zero); + Marshaller.Free (ndom); + EnsureHash (); + handlers [result] = logFunc; + + return result; + } + + [DllImport("libglib-2.0-0.dll")] + static extern uint g_log_remove_handler (IntPtr log_domain, uint handler_id); + + public static void RemoveLogHandler (string logDomain, uint handlerID) + { + if (handlers != null && handlers.ContainsKey (handlerID)) + handlers.Remove (handlerID); + + IntPtr ndom = Marshaller.StringToPtrGStrdup (logDomain); + g_log_remove_handler (ndom, handlerID); + Marshaller.Free (ndom); + } + + + [DllImport("libglib-2.0-0.dll")] + static extern PrintFunc g_set_print_handler (PrintFunc handler); + + public static PrintFunc SetPrintHandler (PrintFunc handler) + { + EnsureHash (); + handlers ["PrintHandler"] = handler; + + return g_set_print_handler (handler); + } + + [DllImport("libglib-2.0-0.dll")] + static extern PrintFunc g_set_printerr_handler (PrintFunc handler); + + public static PrintFunc SetPrintErrorHandler (PrintFunc handler) + { + EnsureHash (); + handlers ["PrintErrorHandler"] = handler; + + return g_set_printerr_handler (handler); + } + + [DllImport("libglib-2.0-0.dll")] + static extern void g_log_default_handler (IntPtr log_domain, LogLevelFlags log_level, IntPtr message, IntPtr unused_data); + + public static void DefaultHandler (string logDomain, LogLevelFlags logLevel, string message) + + { + IntPtr ndom = Marshaller.StringToPtrGStrdup (logDomain); + IntPtr nmess = Marshaller.StringToPtrGStrdup (message); + g_log_default_handler (ndom, logLevel, nmess, IntPtr.Zero); + Marshaller.Free (ndom); + Marshaller.Free (nmess); + } + + [DllImport("libglib-2.0-0.dll")] + extern static LogLevelFlags g_log_set_always_fatal (LogLevelFlags fatal_mask); + + public static LogLevelFlags SetAlwaysFatal (LogLevelFlags fatalMask) + { + return g_log_set_always_fatal (fatalMask); + } + + [DllImport("libglib-2.0-0.dll")] + extern static LogLevelFlags g_log_set_fatal_mask (IntPtr log_domain, LogLevelFlags fatal_mask); + + public static LogLevelFlags SetAlwaysFatal (string logDomain, LogLevelFlags fatalMask) + { + IntPtr ndom = Marshaller.StringToPtrGStrdup (logDomain); + LogLevelFlags result = g_log_set_fatal_mask (ndom, fatalMask); + Marshaller.Free (ndom); + return result; + } + + /* + * Some common logging methods. + * + * Sample usage: + * + * // Print the messages for the NULL domain + * LogFunc logFunc = new LogFunc (Log.PrintLogFunction); + * Log.SetLogHandler (null, LogLevelFlags.All, logFunc); + * + * // Print messages and stack trace for Gtk critical messages + * logFunc = new LogFunc (Log.PrintTraceLogFunction); + * Log.SetLogHandler ("Gtk", LogLevelFlags.Critical, logFunc); + * + */ + + public static void PrintLogFunction (string domain, LogLevelFlags level, string message) + { + Console.WriteLine ("Domain: '{0}' Level: {1}", domain, level); + Console.WriteLine ("Message: {0}", message); + } + + public static void PrintTraceLogFunction (string domain, LogLevelFlags level, string message) + { + PrintLogFunction (domain, level, message); + Console.WriteLine ("Trace follows:\n{0}", new System.Diagnostics.StackTrace ()); + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/MainContext.cs b/gstreamer-sharp/glib-sharp/MainContext.cs new file mode 100644 index 0000000000..a56899bce4 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/MainContext.cs @@ -0,0 +1,56 @@ +// GLib.MainContext.cs - mainContext class implementation +// +// Author: Radek Doulik +// +// Copyright (c) 2003 Radek Doulik +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + public class MainContext { + + [DllImport("libglib-2.0-0.dll")] + static extern int g_main_depth (); + public static int Depth { + get { return g_main_depth (); } + } + + [DllImport("libglib-2.0-0.dll")] + static extern bool g_main_context_iteration (IntPtr Raw, bool MayBlock); + + public static bool Iteration () + { + return g_main_context_iteration (IntPtr.Zero, false); + } + + public static bool Iteration (bool MayBlock) + { + return g_main_context_iteration (IntPtr.Zero, MayBlock); + } + + [DllImport("libglib-2.0-0.dll")] + static extern bool g_main_context_pending (IntPtr Raw); + + public static bool Pending () + { + return g_main_context_pending (IntPtr.Zero); + } + } +} diff --git a/gstreamer-sharp/glib-sharp/MainLoop.cs b/gstreamer-sharp/glib-sharp/MainLoop.cs new file mode 100644 index 0000000000..67caf43198 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/MainLoop.cs @@ -0,0 +1,71 @@ +// GLib.MainLoop.cs - g_main_loop class implementation +// +// Author: Jeroen Zwartepoorte +// +// Copyright (c) 2004 Jeroen Zwartepoorte +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + +using System; +using System.Runtime.InteropServices; + +namespace GLib { + public class MainLoop { + private IntPtr handle; + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_main_loop_new (IntPtr context, bool isRunning); + + public MainLoop () + { + handle = g_main_loop_new (IntPtr.Zero, false); + } + + [DllImport("libglib-2.0-0.dll")] + static extern void g_main_loop_unref (IntPtr loop); + + ~MainLoop () + { + g_main_loop_unref (handle); + handle = IntPtr.Zero; + } + + [DllImport("libglib-2.0-0.dll")] + static extern bool g_main_loop_is_running (IntPtr loop); + + public bool IsRunning { + get { + return g_main_loop_is_running (handle); + } + } + + [DllImport("libglib-2.0-0.dll")] + static extern void g_main_loop_run (IntPtr loop); + + public void Run () + { + g_main_loop_run (handle); + } + + [DllImport("libglib-2.0-0.dll")] + static extern void g_main_loop_quit (IntPtr loop); + + public void Quit () + { + g_main_loop_quit (handle); + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/ManagedValue.cs b/gstreamer-sharp/glib-sharp/ManagedValue.cs new file mode 100644 index 0000000000..19ac3a21f5 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/ManagedValue.cs @@ -0,0 +1,149 @@ +// GLib.ManagedValue.cs : Managed types boxer +// +// Author: Rachel Hestilow +// +// Copyright (c) 2002 Rachel Hestilow +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + using System; + using System.Collections; + using System.Runtime.InteropServices; + using GLib; + + internal class ManagedValue { + + GCHandle gch; + object instance; + int ref_count = 1; + + private ManagedValue (object instance) + { + this.instance = instance; + gch = GCHandle.Alloc (this); + } + + IntPtr Handle { + get { return (IntPtr) gch; } + } + + object Instance { + get { return instance; } + } + + void Ref () + { + ref_count++; + } + + void Unref () + { + if (--ref_count == 0) { + instance = null; + gch.Free (); + } + } + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate IntPtr CopyFunc (IntPtr gch); + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate void FreeFunc (IntPtr gch); + + static CopyFunc copy; + static FreeFunc free; + static GType boxed_type = GType.Invalid; + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_boxed_type_register_static (IntPtr typename, CopyFunc copy_func, FreeFunc free_func); + + public static GType GType { + get { + if (boxed_type == GType.Invalid) { + copy = new CopyFunc (Copy); + free = new FreeFunc (Free); + + IntPtr name = Marshaller.StringToPtrGStrdup ("GtkSharpValue"); + boxed_type = new GLib.GType (g_boxed_type_register_static (name, copy, free)); + Marshaller.Free (name); + } + + return boxed_type; + } + } + + static ManagedValue FromHandle (IntPtr ptr) + { + GCHandle gch = (GCHandle) ptr; + ManagedValue val = gch.Target as ManagedValue; + if (val == null) + throw new Exception ("Unexpected GCHandle received."); + return val; + } + + static IntPtr Copy (IntPtr ptr) + { + try { + if (ptr == IntPtr.Zero) + return ptr; + ManagedValue val = FromHandle (ptr); + val.Ref (); + return ptr; + } catch (Exception e) { + ExceptionManager.RaiseUnhandledException (e, false); + } + + return IntPtr.Zero; + } + + static void Free (IntPtr ptr) + { + try { + if (ptr == IntPtr.Zero) + return; + ManagedValue val = FromHandle (ptr); + val.Unref (); + } catch (Exception e) { + ExceptionManager.RaiseUnhandledException (e, false); + } + } + + public static IntPtr WrapObject (object obj) + { + if (obj == null) + return IntPtr.Zero; + return new ManagedValue (obj).Handle; + } + + public static object ObjectForWrapper (IntPtr ptr) + { + if (ptr == IntPtr.Zero) + return null; + ManagedValue val = FromHandle (ptr); + return val == null ? null : val.Instance; + } + + public static void ReleaseWrapper (IntPtr ptr) + { + if (ptr == IntPtr.Zero) + return; + + ManagedValue val = FromHandle (ptr); + val.Unref (); + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/Markup.cs b/gstreamer-sharp/glib-sharp/Markup.cs new file mode 100644 index 0000000000..254199371f --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Markup.cs @@ -0,0 +1,46 @@ +// Markup.cs: Wrapper for the Markup code in Glib +// +// Authors: +// Miguel de Icaza (miguel@ximian.com) +// +// Copyright (c) 2003 Ximian, Inc. +// +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + +using System; +using System.Runtime.InteropServices; + +namespace GLib { + + + public class Markup { + private Markup () {} + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_markup_escape_text (IntPtr text, int len); + + static public string EscapeText (string s) + { + if (s == null) + return String.Empty; + + IntPtr native = Marshaller.StringToPtrGStrdup (s); + string result = Marshaller.PtrToStringGFree (g_markup_escape_text (native, -1)); + Marshaller.Free (native); + return result; + } + } +} diff --git a/gstreamer-sharp/glib-sharp/Marshaller.cs b/gstreamer-sharp/glib-sharp/Marshaller.cs new file mode 100644 index 0000000000..520c9a38d0 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Marshaller.cs @@ -0,0 +1,413 @@ +// GLibSharp.Marshaller.cs : Marshalling utils +// +// Author: Rachel Hestilow +// Mike Kestner +// +// Copyright (c) 2002, 2003 Rachel Hestilow +// Copyright (c) 2004 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + using System; + using System.Runtime.InteropServices; + + public class Marshaller { + + private Marshaller () {} + + [DllImport("libglib-2.0-0.dll")] + static extern void g_free (IntPtr mem); + + public static void Free (IntPtr ptr) + { + g_free (ptr); + } + + public static void Free (IntPtr[] ptrs) + { + if (ptrs == null) + return; + + for (int i = 0; i < ptrs.Length; i++) + g_free (ptrs [i]); + } + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_filename_to_utf8 (IntPtr mem, int len, IntPtr read, out IntPtr written, out IntPtr error); + + public static string FilenamePtrToString (IntPtr ptr) + { + if (ptr == IntPtr.Zero) return null; + + IntPtr dummy, error; + IntPtr utf8 = g_filename_to_utf8 (ptr, -1, IntPtr.Zero, out dummy, out error); + if (error != IntPtr.Zero) + throw new GLib.GException (error); + return Utf8PtrToString (utf8); + } + + public static string FilenamePtrToStringGFree (IntPtr ptr) + { + string ret = FilenamePtrToString (ptr); + g_free (ptr); + return ret; + } + + static unsafe ulong strlen (IntPtr s) + { + ulong cnt = 0; + byte *b = (byte *)s; + while (*b != 0) { + b++; + cnt++; + } + return cnt; + } + + public static string Utf8PtrToString (IntPtr ptr) + { + if (ptr == IntPtr.Zero) + return null; + + int len = (int) (uint) strlen (ptr); + byte[] bytes = new byte [len]; + Marshal.Copy (ptr, bytes, 0, len); + return System.Text.Encoding.UTF8.GetString (bytes); + } + + public static string[] Utf8PtrToString (IntPtr[] ptrs) { + // The last pointer is a null terminator. + string[] ret = new string[ptrs.Length - 1]; + for (int i = 0; i < ret.Length; i++) + ret[i] = Utf8PtrToString (ptrs[i]); + return ret; + } + + public static string PtrToStringGFree (IntPtr ptr) + { + string ret = Utf8PtrToString (ptr); + g_free (ptr); + return ret; + } + + public static string[] PtrToStringGFree (IntPtr[] ptrs) { + // The last pointer is a null terminator. + string[] ret = new string[ptrs.Length - 1]; + for (int i = 0; i < ret.Length; i++) { + ret[i] = Utf8PtrToString (ptrs[i]); + g_free (ptrs[i]); + } + return ret; + } + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_filename_from_utf8 (IntPtr mem, int len, IntPtr read, out IntPtr written, out IntPtr error); + + public static IntPtr StringToFilenamePtr (string str) + { + if (str == null) + return IntPtr.Zero; + + IntPtr dummy, error; + IntPtr utf8 = StringToPtrGStrdup (str); + IntPtr result = g_filename_from_utf8 (utf8, -1, IntPtr.Zero, out dummy, out error); + g_free (utf8); + if (error != IntPtr.Zero) + throw new GException (error); + + return result; + } + + public static IntPtr StringToPtrGStrdup (string str) { + if (str == null) + return IntPtr.Zero; + byte[] bytes = System.Text.Encoding.UTF8.GetBytes (str); + IntPtr result = g_malloc (new UIntPtr ((ulong)bytes.Length + 1)); + Marshal.Copy (bytes, 0, result, bytes.Length); + Marshal.WriteByte (result, bytes.Length, 0); + return result; + } + + public static string StringFormat (string format, params object[] args) { + string ret = String.Format (format, args); + if (ret.IndexOf ('%') == -1) + return ret; + else + return ret.Replace ("%", "%%"); + } + + public static IntPtr[] StringArrayToNullTermPointer (string[] strs) + { + if (strs == null) + return null; + IntPtr[] result = new IntPtr [strs.Length + 1]; + for (int i = 0; i < strs.Length; i++) + result [i] = StringToPtrGStrdup (strs [i]); + result [strs.Length] = IntPtr.Zero; + return result; + } + + [DllImport("libglib-2.0-0.dll")] + static extern void g_strfreev (IntPtr mem); + + public static void StrFreeV (IntPtr null_term_array) + { + g_strfreev (null_term_array); + } + + public static string[] NullTermPtrToStringArray (IntPtr null_term_array, bool owned) + { + if (null_term_array == IntPtr.Zero) + return new string [0]; + + int count = 0; + System.Collections.ArrayList result = new System.Collections.ArrayList (); + IntPtr s = Marshal.ReadIntPtr (null_term_array, count++ * IntPtr.Size); + while (s != IntPtr.Zero) { + result.Add (Utf8PtrToString (s)); + s = Marshal.ReadIntPtr (null_term_array, count++ * IntPtr.Size); + } + + if (owned) + g_strfreev (null_term_array); + + return (string[]) result.ToArray (typeof(string)); + } + + public static string[] PtrToStringArrayGFree (IntPtr string_array) + { + if (string_array == IntPtr.Zero) + return new string [0]; + + int count = 0; + while (Marshal.ReadIntPtr (string_array, count*IntPtr.Size) != IntPtr.Zero) + ++count; + + string[] members = new string[count]; + for (int i = 0; i < count; ++i) { + IntPtr s = Marshal.ReadIntPtr (string_array, i * IntPtr.Size); + members[i] = GLib.Marshaller.PtrToStringGFree (s); + } + GLib.Marshaller.Free (string_array); + return members; + } + + // Argv marshalling -- unpleasantly complex, but + // don't know of a better way to do it. + // + // Currently, the 64-bit cleanliness is + // hypothetical. It's also ugly, but I don't know of a + // construct to handle both 32 and 64 bitness + // transparently, since we need to alloc buffers of + // [native pointer size] * [count] bytes. + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_malloc(UIntPtr size); + + public static IntPtr Malloc (ulong size) + { + return g_malloc (new UIntPtr (size)); + } + + static bool check_sixtyfour () { + int szint = Marshal.SizeOf (typeof (int)); + int szlong = Marshal.SizeOf (typeof (long)); + int szptr = IntPtr.Size; + + if (szptr == szint) + return false; + if (szptr == szlong) + return true; + + throw new Exception ("Pointers are neither int- nor long-sized???"); + } + + static IntPtr make_buf_32 (string[] args) + { + int[] ptrs = new int[args.Length]; + + for (int i = 0; i < args.Length; i++) + ptrs[i] = (int) Marshal.StringToHGlobalAuto (args[i]); + + IntPtr buf = g_malloc (new UIntPtr ((ulong) Marshal.SizeOf(typeof(int)) * + (ulong) args.Length)); + Marshal.Copy (ptrs, 0, buf, ptrs.Length); + return buf; + } + + static IntPtr make_buf_64 (string[] args) + { + long[] ptrs = new long[args.Length]; + + for (int i = 0; i < args.Length; i++) + ptrs[i] = (long) Marshal.StringToHGlobalAuto (args[i]); + + IntPtr buf = g_malloc (new UIntPtr ((ulong) Marshal.SizeOf(typeof(long)) * + (ulong) args.Length)); + Marshal.Copy (ptrs, 0, buf, ptrs.Length); + return buf; + } + + [Obsolete ("Use GLib.Argv instead to avoid leaks.")] + public static IntPtr ArgvToArrayPtr (string[] args) + { + if (args.Length == 0) + return IntPtr.Zero; + + if (check_sixtyfour ()) + return make_buf_64 (args); + + return make_buf_32 (args); + } + + // should we be freeing these pointers? they're marshalled + // from our own strings, so I think not ... + + static string[] unmarshal_32 (IntPtr buf, int argc) + { + int[] ptrs = new int[argc]; + string[] args = new string[argc]; + + Marshal.Copy (buf, ptrs, 0, argc); + + for (int i = 0; i < ptrs.Length; i++) + args[i] = Marshal.PtrToStringAuto ((IntPtr) ptrs[i]); + + return args; + } + + static string[] unmarshal_64 (IntPtr buf, int argc) + { + long[] ptrs = new long[argc]; + string[] args = new string[argc]; + + Marshal.Copy (buf, ptrs, 0, argc); + + for (int i = 0; i < ptrs.Length; i++) + args[i] = Marshal.PtrToStringAuto ((IntPtr) ptrs[i]); + + return args; + } + + [Obsolete ("Use GLib.Argv instead to avoid leaks.")] + public static string[] ArrayPtrToArgv (IntPtr array, int argc) + { + if (argc == 0) + return new string[0]; + + if (check_sixtyfour ()) + return unmarshal_64 (array, argc); + + return unmarshal_32 (array, argc); + } + + static DateTime local_epoch = new DateTime (1970, 1, 1, 0, 0, 0); + static int utc_offset = (int) (TimeZone.CurrentTimeZone.GetUtcOffset (DateTime.Now)).TotalSeconds; + + public static IntPtr DateTimeTotime_t (DateTime time) + { + return new IntPtr (((long)time.Subtract (local_epoch).TotalSeconds) - utc_offset); + } + + public static DateTime time_tToDateTime (IntPtr time_t) + { + return local_epoch.AddSeconds (time_t.ToInt64 () + utc_offset); + } + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_malloc0 (UIntPtr size); + + [DllImport("libglib-2.0-0.dll")] + static extern int g_unichar_to_utf8 (uint c, IntPtr buf); + + public static char GUnicharToChar (uint ucs4_char) + { + if (ucs4_char == 0) + return (char) 0; + + string ret = GUnicharToString (ucs4_char); + if (ret.Length != 1) + throw new ArgumentOutOfRangeException ("ucs4char is not representable by a char."); + + return ret [0]; + } + + public static string GUnicharToString (uint ucs4_char) + { + if (ucs4_char == 0) + return String.Empty; + + IntPtr buf = g_malloc0 (new UIntPtr (7)); + g_unichar_to_utf8 (ucs4_char, buf); + return PtrToStringGFree (buf); + } + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_utf16_to_ucs4 (ref ushort c, IntPtr len, IntPtr d1, IntPtr d2, IntPtr d3); + + public static uint CharToGUnichar (char c) + { + ushort val = (ushort) c; + IntPtr ucs4_str = g_utf16_to_ucs4 (ref val, new IntPtr (1), IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); + uint result = (uint) Marshal.ReadInt32 (ucs4_str); + g_free (ucs4_str); + return result; + } + + public static IntPtr StructureToPtrAlloc (object o) + { + IntPtr result = Marshal.AllocHGlobal (Marshal.SizeOf (o)); + Marshal.StructureToPtr (o, result, false); + return result; + } + + public static Array ListPtrToArray (IntPtr list_ptr, Type list_type, bool owned, bool elements_owned, Type elem_type) + { + Type array_type = elem_type == typeof (ListBase.FilenameString) ? typeof (string) : elem_type; + ListBase list; + if (list_type == typeof(GLib.List)) + list = new GLib.List (list_ptr, elem_type, owned, elements_owned); + else + list = new GLib.SList (list_ptr, elem_type, owned, elements_owned); + + using (list) + return ListToArray (list, array_type); + } + + public static Array PtrArrayToArray (IntPtr list_ptr, bool owned, bool elements_owned, Type elem_type) + { + GLib.PtrArray array = new GLib.PtrArray (list_ptr, elem_type, owned, elements_owned); + Array ret = Array.CreateInstance (elem_type, array.Count); + array.CopyTo (ret, 0); + array.Dispose (); + return ret; + } + + public static Array ListToArray (ListBase list, System.Type type) + { + Array result = Array.CreateInstance (type, list.Count); + if (list.Count > 0) + list.CopyTo (result, 0); + + if (type.IsSubclassOf (typeof (GLib.Opaque))) + list.elements_owned = false; + + return result; + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/MissingIntPtrCtorException.cs b/gstreamer-sharp/glib-sharp/MissingIntPtrCtorException.cs new file mode 100644 index 0000000000..f5633430ca --- /dev/null +++ b/gstreamer-sharp/glib-sharp/MissingIntPtrCtorException.cs @@ -0,0 +1,35 @@ +// MissingIntPtrCtorException.cs : Exception for missing IntPtr ctors +// +// Authors: Mike Kestner +// +// Copyright (c) 2004 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + public class MissingIntPtrCtorException : Exception + { + public MissingIntPtrCtorException (string msg) : base (msg) + { + } + + } +} + diff --git a/gstreamer-sharp/glib-sharp/NotifyHandler.cs b/gstreamer-sharp/glib-sharp/NotifyHandler.cs new file mode 100644 index 0000000000..0ea3e250bc --- /dev/null +++ b/gstreamer-sharp/glib-sharp/NotifyHandler.cs @@ -0,0 +1,35 @@ +// Copyright (c) 2005 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + public delegate void NotifyHandler (object o, NotifyArgs args); + + public class NotifyArgs : GLib.SignalArgs { + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_get_name (IntPtr pspec); + + public string Property { + get { + IntPtr raw_ret = g_param_spec_get_name ((IntPtr) Args[0]); + return Marshaller.Utf8PtrToString (raw_ret); + } + } + } +} diff --git a/gstreamer-sharp/glib-sharp/Object.cs b/gstreamer-sharp/glib-sharp/Object.cs new file mode 100644 index 0000000000..d210488868 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Object.cs @@ -0,0 +1,738 @@ +// Object.cs - GObject class wrapper implementation +// +// Authors: Mike Kestner +// +// Copyright (c) 2001-2003 Mike Kestner +// Copyright (c) 2004-2005 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.ComponentModel; + using System.Reflection; + using System.Runtime.InteropServices; + using System.Text; + + public class Object : IWrapper, IDisposable { + + IntPtr handle; + ToggleRef tref; + bool disposed = false; + Hashtable data; + static Hashtable Objects = new Hashtable(); + static ArrayList PendingDestroys = new ArrayList (); + static bool idle_queued; + + ~Object () + { + lock (PendingDestroys) { + lock (Objects) { + if (Objects[Handle] is ToggleRef) + PendingDestroys.Add (Objects [Handle]); + Objects.Remove (Handle); + } + if (!idle_queued){ + Timeout.Add (50, new TimeoutHandler (PerformQueuedUnrefs)); + idle_queued = true; + } + } + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_object_unref (IntPtr raw); + + static bool PerformQueuedUnrefs () + { + object [] references; + + lock (PendingDestroys){ + references = new object [PendingDestroys.Count]; + PendingDestroys.CopyTo (references, 0); + PendingDestroys.Clear (); + idle_queued = false; + } + + foreach (ToggleRef r in references) + r.Free (); + + return false; + } + + public virtual void Dispose () + { + if (disposed) + return; + + disposed = true; + ToggleRef toggle_ref = Objects [Handle] as ToggleRef; + Objects.Remove (Handle); + try { + if (toggle_ref != null) + toggle_ref.Free (); + } catch (Exception e) { + Console.WriteLine ("Exception while disposing a " + this + " in Gtk#"); + throw e; + } + handle = IntPtr.Zero; + GC.SuppressFinalize (this); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_object_ref (IntPtr raw); + + public static Object GetObject(IntPtr o, bool owned_ref) + { + if (o == IntPtr.Zero) + return null; + + Object obj = null; + + if (Objects.Contains (o)) { + ToggleRef toggle_ref = Objects [o] as ToggleRef; + if (toggle_ref != null && toggle_ref.IsAlive) + obj = toggle_ref.Target; + } + + if (obj != null && obj.Handle == o) { + if (owned_ref) + g_object_unref (obj.Handle); + return obj; + } + + if (!owned_ref) + g_object_ref (o); + + obj = GLib.ObjectManager.CreateObject(o); + if (obj == null) { + g_object_unref (o); + return null; + } + + return obj; + } + + public static Object GetObject(IntPtr o) + { + return GetObject (o, false); + } + + private static void ConnectDefaultHandlers (GType gtype, System.Type t) + { + foreach (MethodInfo minfo in t.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly)) { + MethodInfo baseinfo = minfo.GetBaseDefinition (); + if (baseinfo == minfo) + continue; + + foreach (object attr in baseinfo.GetCustomAttributes (typeof (DefaultSignalHandlerAttribute), false)) { + DefaultSignalHandlerAttribute sigattr = attr as DefaultSignalHandlerAttribute; + MethodInfo connector = sigattr.Type.GetMethod (sigattr.ConnectionMethod, BindingFlags.Static | BindingFlags.NonPublic, null, new Type[] { typeof (GType) }, new ParameterModifier [0]); + object[] parms = new object [1]; + parms [0] = gtype; + connector.Invoke (null, parms); + break; + } + } + + } + + private static void InvokeClassInitializers (GType gtype, System.Type t) + { + object[] parms = {gtype, t}; + + BindingFlags flags = BindingFlags.Static | BindingFlags.NonPublic; + + foreach (TypeInitializerAttribute tia in t.GetCustomAttributes (typeof (TypeInitializerAttribute), true)) { + MethodInfo m = tia.Type.GetMethod (tia.MethodName, flags); + if (m != null) + m.Invoke (null, parms); + } + + for (Type curr = t; curr != typeof(GLib.Object); curr = curr.BaseType) { + + if (curr.Assembly.IsDefined (typeof (IgnoreClassInitializersAttribute), false)) + continue; + + foreach (MethodInfo minfo in curr.GetMethods(flags)) + if (minfo.IsDefined (typeof (ClassInitializerAttribute), true)) + minfo.Invoke (null, parms); + } + } + + // Key: The pointer to the ParamSpec of the property + // Value: The corresponding PropertyInfo object + static Hashtable properties; + static Hashtable Properties { + get { + if (properties == null) + properties = new Hashtable (); + return properties; + } + } + + [StructLayout(LayoutKind.Sequential)] + struct GTypeClass { + public IntPtr gtype; + } + + [StructLayout(LayoutKind.Sequential)] + struct GObjectClass { + GTypeClass type_class; + IntPtr construct_props; + public ConstructorDelegate constructor_cb; + public SetPropertyDelegate set_prop_cb; + public GetPropertyDelegate get_prop_cb; + IntPtr dispose; + IntPtr finalize; + IntPtr dispatch_properties_changed; + IntPtr notify; + public ConstructedDelegate constructed_cb; + IntPtr dummy1; + IntPtr dummy2; + IntPtr dummy3; + IntPtr dummy4; + IntPtr dummy5; + IntPtr dummy6; + IntPtr dummy7; + } + + static Hashtable class_structs; + + static GObjectClass GetClassStruct (GLib.GType gtype, bool use_cache) + { + if (class_structs == null) + class_structs = new Hashtable (); + + if (use_cache && class_structs.Contains (gtype)) + return (GObjectClass) class_structs [gtype]; + else { + IntPtr class_ptr = gtype.ClassPtr; + GObjectClass class_struct = (GObjectClass) Marshal.PtrToStructure (class_ptr, typeof (GObjectClass)); + if (use_cache) + class_structs.Add (gtype, class_struct); + return class_struct; + } + } + + static void OverrideClassStruct (GLib.GType gtype, GObjectClass class_struct) + { + IntPtr class_ptr = gtype.ClassPtr; + Marshal.StructureToPtr (class_struct, class_ptr, false); + } + + static void OverridePropertyHandlers (GType gtype, GetPropertyDelegate get_cb, SetPropertyDelegate set_cb) + { + GObjectClass klass = GetClassStruct (gtype, false); + klass.get_prop_cb = get_cb; + klass.set_prop_cb = set_cb; + OverrideClassStruct (gtype, klass); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_object_class_install_property (IntPtr klass, uint prop_id, IntPtr param_spec); + + static IntPtr RegisterProperty (GType type, string name, string nick, string blurb, uint property_id, GType property_type, bool can_read, bool can_write) + { + IntPtr declaring_class = type.ClassPtr; + ParamSpec pspec = new ParamSpec (name, nick, blurb, property_type, can_read, can_write); + + g_object_class_install_property (declaring_class, property_id, pspec.Handle); + return pspec.Handle; + } + + static ConstructorDelegate Constructor_cb = new ConstructorDelegate (constructor_cb); + delegate IntPtr ConstructorDelegate (IntPtr gtype, uint n_construct_properties, IntPtr construct_properties); + + [StructLayout(LayoutKind.Sequential)] + struct GObjectConstructParam { + public IntPtr pspec; + public IntPtr value; + } + + static IntPtr constructor_cb (IntPtr gtype, uint n_construct_properties, IntPtr construct_properties) + { + GType type = new GLib.GType (gtype); + IntPtr instance = GetClassStruct (type.ThresholdType, false).constructor_cb (gtype, n_construct_properties, construct_properties); + for (int i = 0; i < n_construct_properties; i++) { + IntPtr p = new IntPtr ((long) construct_properties + i * Marshal.SizeOf (typeof (GObjectConstructParam))); + + GObjectConstructParam cparam = (GObjectConstructParam) Marshal.PtrToStructure (p, typeof (GObjectConstructParam)); + + ParamSpec pspec = new ParamSpec (cparam.pspec); + GLib.Value val = (Value) Marshal.PtrToStructure (cparam.value, typeof (Value)); + + if (pspec.Name == "gtk-sharp-managed-instance" && (IntPtr) val.Val != IntPtr.Zero) { + GCHandle gch = (GCHandle) (IntPtr) val.Val; + Object o = (GLib.Object) gch.Target; + o.Raw = instance; + } + } + + return instance; + } + + static ConstructedDelegate Constructed_cb = new ConstructedDelegate (constructed_cb); + [GLib.CDeclCallback] + delegate void ConstructedDelegate (IntPtr o); + + static void constructed_cb (IntPtr o) + { + GLib.Object __obj = GLib.Object.GetObject (o, false) as GLib.Object; + ConstructedDelegate unmanaged = GetClassStruct (__obj.LookupGType ().ThresholdType, true).constructed_cb; + if (unmanaged != null) + unmanaged (__obj.Handle); + } + + static SetPropertyDelegate Set_prop_dummy_cb = new SetPropertyDelegate (set_prop_dummy_cb); + static void set_prop_dummy_cb (IntPtr GObject, uint property_id, ref GLib.Value value, IntPtr pspec) {} + + static void AddProperties (GType gtype, System.Type t) + { + uint idx = 1; + + if (gtype.BaseType == gtype.ThresholdType) { + GObjectClass gobject_class = GetClassStruct (gtype, false); + gobject_class.constructor_cb = Constructor_cb; + gobject_class.constructed_cb = Constructed_cb; + gobject_class.set_prop_cb = Set_prop_dummy_cb; + OverrideClassStruct (gtype, gobject_class); + + IntPtr declaring_class = gtype.ClassPtr; + ParamSpec pspec = new ParamSpec ("gtk-sharp-managed-instance", "", "", GType.Pointer, ParamFlags.Writable | ParamFlags.ConstructOnly); + g_object_class_install_property (declaring_class, idx, pspec.Handle); + idx++; + } + + bool handlers_overridden = false; + foreach (PropertyInfo pinfo in t.GetProperties (BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)) { + foreach (object attr in pinfo.GetCustomAttributes (typeof (PropertyAttribute), false)) { + if(pinfo.GetIndexParameters().Length > 0) + throw(new InvalidOperationException(String.Format("GLib.RegisterPropertyAttribute cannot be applied to property {0} of type {1} because the property expects one or more indexed parameters", pinfo.Name, t.FullName))); + + PropertyAttribute property_attr = attr as PropertyAttribute; + if (!handlers_overridden) { + OverridePropertyHandlers (gtype, GetPropertyHandler, SetPropertyHandler); + handlers_overridden = true; + } + + try { + IntPtr param_spec = RegisterProperty (gtype, property_attr.Name, property_attr.Nickname, property_attr.Blurb, idx, (GType) pinfo.PropertyType, pinfo.CanRead, pinfo.CanWrite); + Properties.Add (param_spec, pinfo); + idx++; + } catch (ArgumentException) { + throw new InvalidOperationException (String.Format ("GLib.PropertyAttribute cannot be applied to property {0} of type {1} because the return type of the property is not supported", pinfo.Name, t.FullName)); + } + } + } + } + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate void GetPropertyDelegate (IntPtr GObject, uint property_id, ref GLib.Value value, IntPtr pspec); + + static void GetPropertyCallback (IntPtr handle, uint property_id, ref GLib.Value value, IntPtr param_spec) + { + if (!Properties.Contains (param_spec)) + return; + + GLib.Object obj = GLib.Object.GetObject (handle, false); + value.Val = (Properties [param_spec] as PropertyInfo).GetValue (obj, new object [0]); + } + + static GetPropertyDelegate get_property_handler; + static GetPropertyDelegate GetPropertyHandler { + get { + if (get_property_handler == null) + get_property_handler = new GetPropertyDelegate (GetPropertyCallback); + return get_property_handler; + } + } + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate void SetPropertyDelegate (IntPtr GObject, uint property_id, ref GLib.Value value, IntPtr pspec); + + static void SetPropertyCallback(IntPtr handle, uint property_id, ref GLib.Value value, IntPtr param_spec) + { + if (!Properties.Contains (param_spec)) + return; + + GLib.Object obj = GLib.Object.GetObject (handle, false); + (Properties [param_spec] as PropertyInfo).SetValue (obj, value.Val, new object [0]); + } + + static SetPropertyDelegate set_property_handler; + static SetPropertyDelegate SetPropertyHandler { + get { + if (set_property_handler == null) + set_property_handler = new SetPropertyDelegate (SetPropertyCallback); + return set_property_handler; + } + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_type_add_interface_static (IntPtr gtype, IntPtr iface_type, ref GInterfaceInfo info); + + static void AddInterfaces (GType gtype, Type t) + { + foreach (Type iface in t.GetInterfaces ()) { + if (!iface.IsDefined (typeof (GInterfaceAttribute), true) || iface.IsAssignableFrom (t.BaseType)) + continue; + + GInterfaceAttribute attr = iface.GetCustomAttributes (typeof (GInterfaceAttribute), false) [0] as GInterfaceAttribute; + GInterfaceAdapter adapter = Activator.CreateInstance (attr.AdapterType, null) as GInterfaceAdapter; + + GInterfaceInfo info = adapter.Info; + g_type_add_interface_static (gtype.Val, adapter.GType.Val, ref info); + } + } + + protected internal static GType RegisterGType (System.Type t) + { + GType gtype = GType.RegisterGObjectType (t); + AddProperties (gtype, t); + ConnectDefaultHandlers (gtype, t); + InvokeClassInitializers (gtype, t); + AddInterfaces (gtype, t); + return gtype; + } + + + protected GType LookupGType () + { + if (Handle != IntPtr.Zero) { + GTypeInstance obj = (GTypeInstance) Marshal.PtrToStructure (Handle, typeof (GTypeInstance)); + GTypeClass klass = (GTypeClass) Marshal.PtrToStructure (obj.g_class, typeof (GTypeClass)); + return new GLib.GType (klass.gtype); + } else { + return LookupGType (GetType ()); + } + } + + protected internal static GType LookupGType (System.Type t) + { + return GType.LookupGObjectType (t); + } + + protected Object (IntPtr raw) + { + Raw = raw; + } + + protected Object () + { + CreateNativeObject (new string [0], new GLib.Value [0]); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_object_new (IntPtr gtype, IntPtr dummy); + + [Obsolete] + protected Object (GType gtype) + { + Raw = g_object_new (gtype.Val, IntPtr.Zero); + } + + struct GParameter { + public IntPtr name; + public GLib.Value val; + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_object_newv (IntPtr gtype, int n_params, GParameter[] parms); + + protected virtual void CreateNativeObject (string[] names, GLib.Value[] vals) + { + GLib.GType gtype = LookupGType (); + bool managed_type = gtype.ToString().StartsWith ("__gtksharp_"); + + GParameter[] parms = new GParameter [names.Length + ((managed_type) ? 1 : 0)]; + + for (int i = 0; i < names.Length; i++) { + parms [i].name = GLib.Marshaller.StringToPtrGStrdup (names [i]); + parms [i].val = vals [i]; + } + + if (managed_type) { + GCHandle gch = GCHandle.Alloc (this); + parms[names.Length].name = GLib.Marshaller.StringToPtrGStrdup ("gtk-sharp-managed-instance"); + parms[names.Length].val = new GLib.Value ((IntPtr) gch); + + Raw = g_object_newv (gtype.Val, parms.Length, parms); + + gch.Free (); + } else { + Raw = g_object_newv (gtype.Val, parms.Length, parms); + } + + foreach (GParameter p in parms) + GLib.Marshaller.Free (p.name); + } + + protected virtual IntPtr Raw { + get { + return handle; + } + set { + if (handle == value) + return; + + if (handle != IntPtr.Zero) { + Objects.Remove (handle); + if (tref != null) { + tref.Free (); + tref = null; + } + } + handle = value; + if (value != IntPtr.Zero) { + tref = new ToggleRef (this); + Objects [value] = tref; + } + } + } + + public static GLib.GType GType { + get { + return GType.Object; + } + } + + protected string TypeName { + get { + return NativeType.ToString (); + } + } + + internal GLib.GType NativeType { + get { + return LookupGType (); + } + } + + internal ToggleRef ToggleRef { + get { + return tref; + } + } + + public IntPtr Handle { + get { + return handle; + } + } + + public IntPtr OwnedHandle { + get { + return g_object_ref (handle); + } + } + + Hashtable before_signals; + [Obsolete ("Replaced by GLib.Signal marshaling mechanism.")] + protected internal Hashtable BeforeSignals { + get { + if (before_signals == null) + before_signals = new Hashtable (); + return before_signals; + } + } + + Hashtable after_signals; + [Obsolete ("Replaced by GLib.Signal marshaling mechanism.")] + protected internal Hashtable AfterSignals { + get { + if (after_signals == null) + after_signals = new Hashtable (); + return after_signals; + } + } + + EventHandlerList before_handlers; + [Obsolete ("Replaced by GLib.Signal marshaling mechanism.")] + protected EventHandlerList BeforeHandlers { + get { + if (before_handlers == null) + before_handlers = new EventHandlerList (); + return before_handlers; + } + } + + EventHandlerList after_handlers; + [Obsolete ("Replaced by GLib.Signal marshaling mechanism.")] + protected EventHandlerList AfterHandlers { + get { + if (after_handlers == null) + after_handlers = new EventHandlerList (); + return after_handlers; + } + } + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate void NotifyDelegate (IntPtr handle, IntPtr pspec, IntPtr gch); + + void NotifyCallback (IntPtr handle, IntPtr pspec, IntPtr gch) + { + try { + GLib.Signal sig = ((GCHandle) gch).Target as GLib.Signal; + if (sig == null) + throw new Exception("Unknown signal GC handle received " + gch); + + NotifyArgs args = new NotifyArgs (); + args.Args = new object[1]; + args.Args[0] = pspec; + NotifyHandler handler = (NotifyHandler) sig.Handler; + handler (GLib.Object.GetObject (handle), args); + } catch (Exception e) { + ExceptionManager.RaiseUnhandledException (e, false); + } + } + + void ConnectNotification (string signal, NotifyHandler handler) + { + Signal sig = Signal.Lookup (this, signal, new NotifyDelegate (NotifyCallback)); + sig.AddDelegate (handler); + } + + public void AddNotification (string property, NotifyHandler handler) + { + ConnectNotification ("notify::" + property, handler); + } + + public void AddNotification (NotifyHandler handler) + { + ConnectNotification ("notify", handler); + } + + void DisconnectNotification (string signal, NotifyHandler handler) + { + Signal sig = Signal.Lookup (this, signal, new NotifyDelegate (NotifyCallback)); + sig.RemoveDelegate (handler); + } + + public void RemoveNotification (string property, NotifyHandler handler) + { + DisconnectNotification ("notify::" + property, handler); + } + + public void RemoveNotification (NotifyHandler handler) + { + DisconnectNotification ("notify", handler); + } + + public override int GetHashCode () + { + return Handle.GetHashCode (); + } + + public Hashtable Data { + get { + if (data == null) + data = new Hashtable (); + + return data; + } + } + + Hashtable persistent_data; + protected Hashtable PersistentData { + get { + if (persistent_data == null) + persistent_data = new Hashtable (); + + return persistent_data; + } + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_object_get_property (IntPtr obj, IntPtr name, ref GLib.Value val); + + protected GLib.Value GetProperty (string name) + { + Value val = new Value (this, name); + IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name); + g_object_get_property (Raw, native_name, ref val); + GLib.Marshaller.Free (native_name); + return val; + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_object_set_property (IntPtr obj, IntPtr name, ref GLib.Value val); + + protected void SetProperty (string name, GLib.Value val) + { + IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name); + g_object_set_property (Raw, native_name, ref val); + GLib.Marshaller.Free (native_name); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_object_notify (IntPtr obj, IntPtr property_name); + + protected void Notify (string property_name) + { + IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (property_name); + g_object_notify (Handle, native_name); + GLib.Marshaller.Free (native_name); + } + + protected static void OverrideVirtualMethod (GType gtype, string name, Delegate cb) + { + Signal.OverrideDefaultHandler (gtype, name, cb); + } + + [DllImport("libgobject-2.0-0.dll")] + protected static extern void g_signal_chain_from_overridden (IntPtr args, ref GLib.Value retval); + + [DllImport("libgobject-2.0-0.dll")] + static extern bool g_type_check_instance_is_a (IntPtr obj, IntPtr gtype); + + internal static bool IsObject (IntPtr obj) + { + return g_type_check_instance_is_a (obj, GType.Object.Val); + } + + [StructLayout(LayoutKind.Sequential)] + struct GTypeInstance { + public IntPtr g_class; + } + + [StructLayout(LayoutKind.Sequential)] + struct GObject { + public GTypeInstance type_instance; + public uint ref_count; + public IntPtr qdata; + } + + protected int RefCount { + get { + GObject native = (GObject) Marshal.PtrToStructure (Handle, typeof (GObject)); + return (int) native.ref_count; + } + } + + internal void Harden () + { + tref.Harden (); + } + + static Object () + { + if (Environment.GetEnvironmentVariable ("GTK_SHARP_DEBUG") != null) + GLib.Log.SetLogHandler ("GLib-GObject", GLib.LogLevelFlags.All, new GLib.LogFunc (GLib.Log.PrintTraceLogFunction)); + } + } +} diff --git a/gstreamer-sharp/glib-sharp/ObjectManager.cs b/gstreamer-sharp/glib-sharp/ObjectManager.cs new file mode 100644 index 0000000000..5e80221234 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/ObjectManager.cs @@ -0,0 +1,89 @@ +// GLib.ObjectManager.cs - GLib ObjectManager class implementation +// +// Author: Mike Kestner +// +// Copyright 2001-2002 Mike Kestner +// Copyright 2004-2005 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + using System.Reflection; + + public class ObjectManager { + + static BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.CreateInstance; + + public static GLib.Object CreateObject (IntPtr raw) + { + if (raw == IntPtr.Zero) + return null; + + Type type = GetTypeOrParent (raw); + + if (type == null) + return null; + + GLib.Object obj; + try { + obj = Activator.CreateInstance (type, flags, null, new object[] {raw}, null) as GLib.Object; + } catch (MissingMethodException) { + throw new GLib.MissingIntPtrCtorException ("GLib.Object subclass " + type + " must provide a protected or public IntPtr ctor to support wrapping of native object handles."); + } + return obj; + } + + [Obsolete ("Replaced by GType.Register (GType, Type)")] + public static void RegisterType (string native_name, string managed_name, string assembly) + { + RegisterType (native_name, managed_name + "," + assembly); + } + + [Obsolete ("Replaced by GType.Register (GType, Type)")] + public static void RegisterType (string native_name, string mangled) + { + RegisterType (GType.FromName (native_name), Type.GetType (mangled)); + } + + [Obsolete ("Replaced by GType.Register (GType, Type)")] + public static void RegisterType (GType native_type, System.Type type) + { + GType.Register (native_type, type); + } + + static Type GetTypeOrParent (IntPtr obj) + { + IntPtr typeid = GType.ValFromInstancePtr (obj); + if (typeid == GType.Invalid.Val) + return null; + + Type result = GType.LookupType (typeid); + while (result == null) { + typeid = g_type_parent (typeid); + if (typeid == IntPtr.Zero) + return null; + result = GType.LookupType (typeid); + } + return result; + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_type_parent (IntPtr typ); + } +} diff --git a/gstreamer-sharp/glib-sharp/Opaque.cs b/gstreamer-sharp/glib-sharp/Opaque.cs new file mode 100644 index 0000000000..4f37283bb3 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Opaque.cs @@ -0,0 +1,150 @@ +// Opaque .cs - Opaque struct wrapper implementation +// +// Authors: Bob Smith +// Mike Kestner +// Rachel Hestilow +// +// Copyright (c) 2001 Bob Smith +// Copyright (c) 2001 Mike Kestner +// Copyright (c) 2002 Rachel Hestilow +// Copyright (c) 2004 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.ComponentModel; + using System.Runtime.InteropServices; + + public class Opaque : IWrapper, IDisposable { + + IntPtr _obj; + bool owned; + + [Obsolete ("Use more explicit overload. This method always returns null")] + public static Opaque GetOpaque (IntPtr o) + { + return null; + } + + public static Opaque GetOpaque (IntPtr o, Type type, bool owned) + { + if (o == IntPtr.Zero) + return null; + + Opaque opaque = (Opaque)Activator.CreateInstance (type, new object[] { o }); + if (owned) { + if (opaque.owned) { + // The constructor took a Ref it shouldn't have, so undo it + opaque.Unref (o); + } + opaque.owned = true; + } else + opaque = opaque.Copy (o); + + return opaque; + } + + public Opaque () + { + owned = true; + } + + public Opaque (IntPtr raw) + { + owned = false; + Raw = raw; + } + + protected IntPtr Raw { + get { + return _obj; + } + set { + if (_obj != IntPtr.Zero) { + Unref (_obj); + if (owned) + Free (_obj); + } + _obj = value; + if (_obj != IntPtr.Zero) { + Ref (_obj); + } + } + } + + ~Opaque () + { + // for compat. All subclasses should have + // generated finalizers if needed now. + } + + public virtual void Dispose () + { + Raw = IntPtr.Zero; + GC.SuppressFinalize (this); + } + + // These take an IntPtr arg so we don't get conflicts if we need + // to have an "[Obsolete] public void Ref ()" + + protected virtual void Ref (IntPtr raw) {} + protected virtual void Unref (IntPtr raw) {} + protected virtual void Free (IntPtr raw) {} + protected virtual Opaque Copy (IntPtr raw) + { + return this; + } + + public IntPtr Handle { + get { + return _obj; + } + } + + public IntPtr OwnedCopy { + get { + Opaque result = Copy (Handle); + result.Owned = false; + return result.Handle; + } + } + + public bool Owned { + get { + return owned; + } + set { + owned = value; + } + } + + public override bool Equals (object o) + { + if (!(o is Opaque)) + return false; + + return (Handle == ((Opaque) o).Handle); + } + + public override int GetHashCode () + { + return Handle.GetHashCode (); + } + } +} diff --git a/gstreamer-sharp/glib-sharp/ParamSpec.cs b/gstreamer-sharp/glib-sharp/ParamSpec.cs new file mode 100644 index 0000000000..2dc0b310f0 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/ParamSpec.cs @@ -0,0 +1,206 @@ +// ParamSpec.cs - GParamSpec class wrapper implementation +// +// Authors: Mike Kestner +// +// Copyright (c) 2008 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + internal enum ParamFlags { + None = 0, + Readable = 1 << 0, + Writable = 1 << 1, + Construct = 1 << 2, + ConstructOnly = 1 << 3, + } + + public class ParamSpec { + + IntPtr handle; + + private static IntPtr CreateParamSpec (string name, string nick, string blurb, GType type, ParamFlags pflags) { + int flags = (int) pflags; + IntPtr ret; + + IntPtr p_name = GLib.Marshaller.StringToPtrGStrdup (name); + IntPtr p_nick = GLib.Marshaller.StringToPtrGStrdup (nick); + IntPtr p_blurb = GLib.Marshaller.StringToPtrGStrdup (blurb); + + if (type == GType.Char) + ret = g_param_spec_char (p_name, p_nick, p_blurb, SByte.MinValue, SByte.MaxValue, 0, flags); + else if (type == GType.UChar) + ret = g_param_spec_uchar (p_name, p_nick, p_blurb, Byte.MinValue, Byte.MaxValue, 0, flags); + else if (type == GType.Boolean) + ret = g_param_spec_boolean (p_name, p_nick, p_blurb, false, flags); + else if (type == GType.Int) + ret = g_param_spec_int (p_name, p_nick, p_blurb, Int32.MinValue, Int32.MaxValue, 0, flags); + else if (type == GType.UInt) + ret = g_param_spec_uint (p_name, p_nick, p_blurb, 0, UInt32.MaxValue, 0, flags); + else if (type == GType.Long) + ret = g_param_spec_long (p_name, p_nick, p_blurb, IntPtr.Zero, IntPtr.Size == 4 ? new IntPtr (Int32.MaxValue) : new IntPtr (Int64.MaxValue), IntPtr.Zero, flags); + else if (type == GType.ULong) + ret = g_param_spec_ulong (p_name, p_nick, p_blurb, UIntPtr.Zero, UIntPtr.Size == 4 ? new UIntPtr (UInt32.MaxValue) : new UIntPtr (UInt64.MaxValue), UIntPtr.Zero, flags); + else if (type == GType.Int64) + ret = g_param_spec_int64 (p_name, p_nick, p_blurb, Int64.MinValue, Int64.MaxValue, 0, flags); + else if (type == GType.UInt64) + ret = g_param_spec_uint64 (p_name, p_nick, p_blurb, 0, UInt64.MaxValue, 0, flags); + /* + else if (type == GType.Enum) + else if (type == GType.Flags) + * TODO: + * Both g_param_spec_enum and g_param_spec_flags expect default property values and the members of the enum seemingly cannot be enumerated + */ + else if (type == GType.Float) + ret = g_param_spec_float (p_name, p_nick, p_blurb, Single.MinValue, Single.MaxValue, 0.0f, flags); + else if (type == GType.Double) + ret = g_param_spec_double (p_name, p_nick, p_blurb, Double.MinValue, Double.MaxValue, 0.0, flags); + else if (type == GType.String) + ret = g_param_spec_string (p_name, p_nick, p_blurb, IntPtr.Zero, flags); + else if (type == GType.Pointer) + ret = g_param_spec_pointer (p_name, p_nick, p_blurb, flags); + else if (type.Val == g_gtype_get_type ()) + ret = g_param_spec_gtype (p_name, p_nick, p_blurb, GType.None.Val, flags); + else if (g_type_is_a (type.Val, GType.Boxed.Val)) + ret = g_param_spec_boxed (p_name, p_nick, p_blurb, type.Val, flags); + else if (g_type_is_a (type.Val, GType.Object.Val)) + ret = g_param_spec_object (p_name, p_nick, p_blurb, type.Val, flags); + else + throw new ArgumentException ("type"); + + GLib.Marshaller.Free (p_name); + GLib.Marshaller.Free (p_nick); + GLib.Marshaller.Free (p_blurb); + + return ret; + } + + internal ParamSpec (string name, string nick, string blurb, GType type, ParamFlags pflags) { + handle = CreateParamSpec (name, nick, blurb, type, pflags); + } + + public ParamSpec (string name, string nick, string blurb, GType type, bool readable, bool writable) + { + ParamFlags pflags = ParamFlags.None; + if (readable) pflags |= ParamFlags.Readable; + if (writable) pflags |= ParamFlags.Writable; + + handle = CreateParamSpec (name, nick, blurb, type, pflags); + } + + public ParamSpec (IntPtr native) + { + handle = native; + } + + public IntPtr Handle { + get { return handle; } + } + + public GType ValueType { + get { + GParamSpec spec = (GParamSpec) Marshal.PtrToStructure (Handle, typeof (GParamSpec)); + return new GType (spec.value_type); + } + } + + public string Name { + get { + GParamSpec spec = (GParamSpec) Marshal.PtrToStructure (Handle, typeof (GParamSpec)); + return GLib.Marshaller.Utf8PtrToString (spec.name); + } + } + + struct GTypeInstance { + IntPtr g_class; + } + + struct GParamSpec { + GTypeInstance g_type_instance; + + public IntPtr name; + ParamFlags flags; + public IntPtr value_type; + IntPtr owner_type; + + IntPtr _nick; + IntPtr _blurb; + IntPtr qdata; + uint ref_count; + uint param_id; + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_char (IntPtr name, IntPtr nick, IntPtr blurb, sbyte min, sbyte max, sbyte dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_uchar (IntPtr name, IntPtr nick, IntPtr blurb, byte min, byte max, byte dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_boolean (IntPtr name, IntPtr nick, IntPtr blurb, bool dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_int (IntPtr name, IntPtr nick, IntPtr blurb, int min, int max, int dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_uint (IntPtr name, IntPtr nick, IntPtr blurb, uint min, uint max, uint dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_long (IntPtr name, IntPtr nick, IntPtr blurb, IntPtr min, IntPtr max, IntPtr dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_ulong (IntPtr name, IntPtr nick, IntPtr blurb, UIntPtr min, UIntPtr max, UIntPtr dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_int64 (IntPtr name, IntPtr nick, IntPtr blurb, long min, long max, long dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_uint64 (IntPtr name, IntPtr nick, IntPtr blurb, ulong min, ulong max, ulong dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_float (IntPtr name, IntPtr nick, IntPtr blurb, float min, float max, float dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_double (IntPtr name, IntPtr nick, IntPtr blurb, double min, double max, double dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_string (IntPtr name, IntPtr nick, IntPtr blurb, IntPtr dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_pointer (IntPtr name, IntPtr nick, IntPtr blurb, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_gtype (IntPtr name, IntPtr nick, IntPtr blurb, IntPtr dval, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_boxed (IntPtr name, IntPtr nick, IntPtr blurb, IntPtr return_type, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_param_spec_object (IntPtr name, IntPtr nick, IntPtr blurb, IntPtr return_type, int flags); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_gtype_get_type (); + + [DllImport("libgobject-2.0-0.dll")] + static extern bool g_type_is_a (IntPtr a, IntPtr b); + + } +} + diff --git a/gstreamer-sharp/glib-sharp/Priority.cs b/gstreamer-sharp/glib-sharp/Priority.cs new file mode 100644 index 0000000000..9c7a964959 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Priority.cs @@ -0,0 +1,31 @@ +// GLib.Priority.cs +// +// Author(s): +// Stephane Delcroix +// +// Copyright (c) 2009 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + +namespace GLib { + public enum Priority + { + High = -100, + Default = 0, + HighIdle = 100, + DefaultIdle = 200, + Low = 300, + } +} diff --git a/gstreamer-sharp/glib-sharp/PropertyAttribute.cs b/gstreamer-sharp/glib-sharp/PropertyAttribute.cs new file mode 100644 index 0000000000..f2f0b3ab40 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/PropertyAttribute.cs @@ -0,0 +1,69 @@ +// PropertyAttribute.cs +// +// Copyright (c) 2004 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + + public sealed class PropertyAttribute : Attribute { + + string blurb; + string nickname; + string name; + + public PropertyAttribute (string name) + { + this.name = name; + } + + public PropertyAttribute (string name, string nickname, string blurb) + { + this.name = name; + this.nickname = nickname; + this.blurb = blurb; + } + + public string Blurb { + get { + return blurb; + } + set { + blurb = value; + } + } + + public string Name { + get { + return name; + } + set { + name = value; + } + } + + public string Nickname { + get { + return nickname; + } + set { + nickname = value; + } + } + } +} diff --git a/gstreamer-sharp/glib-sharp/PtrArray.cs b/gstreamer-sharp/glib-sharp/PtrArray.cs new file mode 100644 index 0000000000..f3371989b0 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/PtrArray.cs @@ -0,0 +1,272 @@ +// PtrArray.cs - PtrArray wrapper implementation +// +// Authors: Mike Gorse +// +// Copyright (c) 2008 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.Runtime.InteropServices; + + public class PtrArray : IDisposable, ICollection, ICloneable, IWrapper { + + private IntPtr handle = IntPtr.Zero; + private bool managed = false; + internal bool elements_owned = false; + protected System.Type element_type = null; + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_ptr_array_sized_new (uint n_preallocs); + + public PtrArray (uint n_preallocs, System.Type element_type, bool owned, bool elements_owned) + { + handle = g_ptr_array_sized_new (n_preallocs); + this.element_type = element_type; + managed = owned; + this.elements_owned = elements_owned; + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_ptr_array_new (); + + public PtrArray (System.Type element_type, bool owned, bool elements_owned) + { + handle = g_ptr_array_new (); + this.element_type = element_type; + managed = owned; + this.elements_owned = elements_owned; + } + + internal PtrArray (IntPtr raw, System.Type element_type, bool owned, bool elements_owned) + { + handle = raw; + this.element_type = element_type; + managed = owned; + this.elements_owned = elements_owned; + } + public PtrArray (IntPtr raw, System.Type element_type) : this (raw, element_type, false, false) {} + + public PtrArray (IntPtr raw) : this (raw, null) {} + + ~PtrArray () + { + Dispose (false); + } + + // IDisposable + public void Dispose () + { + Dispose (true); + GC.SuppressFinalize (this); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_ptr_array_free (IntPtr raw, bool free_seg); + + [DllImport ("libglib-2.0-0.dll")] + static extern void g_object_unref (IntPtr item); + + [DllImport ("libglib-2.0-0.dll")] + static extern void g_free (IntPtr item); + + void Dispose (bool disposing) + { + if (Handle == IntPtr.Zero) + return; + + if (elements_owned) { + int count = Count; + for (uint i = 0; i < count; i++) + if (typeof (GLib.Object).IsAssignableFrom (element_type)) + g_object_unref (NthData (i)); + else if (typeof (GLib.Opaque).IsAssignableFrom (element_type)) + GLib.Opaque.GetOpaque (NthData (i), element_type, true).Dispose (); + else + g_free (NthData (i)); + } + + if (managed) + g_ptr_array_free (Handle, true); + + handle = IntPtr.Zero; + } + + public IntPtr Handle { + get { + return handle; + } + } + + public IntPtr ArrayPtr { + get { + return Marshal.ReadIntPtr (Handle); + } + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_ptr_array_add (IntPtr raw, IntPtr val); + + public void Add (IntPtr val) + { + g_ptr_array_add (Handle, val); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_ptr_array_remove (IntPtr raw, IntPtr data); + + public void Remove (IntPtr data) + { + g_ptr_array_remove (Handle, data); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_ptr_array_remove_range (IntPtr raw, uint index, uint length); + + public void RemoveRange (IntPtr data, uint index, uint length) + { + g_ptr_array_remove_range (Handle, index, length); + } + + struct GPtrArray { + IntPtr pdata; + public uint len; + } + + // ICollection + public int Count { + get { + GPtrArray native = (GPtrArray) Marshal.PtrToStructure (Handle, typeof (GPtrArray)); + return (int) native.len; + } + } + + public object this [int index] { + get { + IntPtr data = NthData ((uint) index); + object ret = null; + ret = DataMarshal (data); + return ret; + } + } + + internal object DataMarshal (IntPtr data) + { + object ret = null; + if (element_type != null) { + if (element_type == typeof (string)) + ret = Marshaller.Utf8PtrToString (data); + else if (element_type == typeof (IntPtr)) + ret = data; + else if (element_type.IsSubclassOf (typeof (GLib.Object))) + ret = GLib.Object.GetObject (data, false); + else if (element_type.IsSubclassOf (typeof (GLib.Opaque))) + ret = GLib.Opaque.GetOpaque (data, element_type, elements_owned); + else if (element_type == typeof (int)) + ret = (int) data; + else if (element_type.IsValueType) + ret = Marshal.PtrToStructure (data, element_type); + else + ret = Activator.CreateInstance (element_type, new object[] {data}); + + } else if (Object.IsObject (data)) + ret = GLib.Object.GetObject (data, false); + + return ret; + } + + internal IntPtr NthData (uint index) + { + return Marshal.ReadIntPtr (ArrayPtr, (int) index * IntPtr.Size);; + } + + // Synchronization could be tricky here. Hmm. + public bool IsSynchronized { + get { return false; } + } + + public object SyncRoot { + get { return null; } + } + + public void CopyTo (Array array, int index) + { + if (array == null) + throw new ArgumentNullException ("Array can't be null."); + + if (index < 0) + throw new ArgumentOutOfRangeException ("Index must be greater than 0."); + + if (index + Count < array.Length) + throw new ArgumentException ("Array not large enough to copy into starting at index."); + + for (int i = 0; i < Count; i++) + ((IList) array) [index + i] = this [i]; + } + + private class ListEnumerator : IEnumerator + { + private int current = -1; + private PtrArray vals; + + public ListEnumerator (PtrArray vals) + { + this.vals = vals; + } + + public object Current { + get { + if (current == -1) + return null; + return vals [current]; + } + } + + public bool MoveNext () + { + if (++current >= vals.Count) { + current = -1; + return false; + } + + return true; + } + + public void Reset () + { + current = -1; + } + } + + // IEnumerable + public IEnumerator GetEnumerator () + { + return new ListEnumerator (this); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_ptr_array_copy (IntPtr raw); + + // ICloneable + public object Clone () + { + return new PtrArray (g_ptr_array_copy (Handle), element_type, false, false); + } + } +} diff --git a/gstreamer-sharp/glib-sharp/SList.cs b/gstreamer-sharp/glib-sharp/SList.cs new file mode 100644 index 0000000000..198bc3de41 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/SList.cs @@ -0,0 +1,99 @@ +// SList.cs - GSList class wrapper implementation +// +// Authors: Mike Kestner +// +// Copyright (c) 2002 Mike Kestner +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + public class SList : ListBase { + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_slist_copy (IntPtr l); + + public override object Clone () + { + return new SList (g_slist_copy (Handle)); + } + + [DllImport("libglib-2.0-0.dll")] + static extern int g_slist_length (IntPtr l); + + internal override int Length (IntPtr list) + { + return g_slist_length (list); + } + + [DllImport("libglib-2.0-0.dll")] + static extern void g_slist_free(IntPtr l); + + internal override void Free (IntPtr list) + { + if (list != IntPtr.Zero) + g_slist_free (list); + } + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_slist_append (IntPtr l, IntPtr raw); + + internal override IntPtr Append (IntPtr list, IntPtr raw) + { + return g_slist_append (list, raw); + } + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_slist_prepend (IntPtr l, IntPtr raw); + + internal override IntPtr Prepend (IntPtr list, IntPtr raw) + { + return g_slist_prepend (list, raw); + } + + + [DllImport("libglib-2.0-0.dll")] + static extern IntPtr g_slist_nth_data (IntPtr l, uint n); + + internal override IntPtr NthData (uint n) + { + return g_slist_nth_data (Handle, n); + } + + public SList (IntPtr raw) : this (raw, null) {} + + public SList (System.Type element_type) : this (IntPtr.Zero, element_type) {} + + public SList (IntPtr raw, System.Type element_type) : this (raw, element_type, false, false) {} + + public SList (IntPtr raw, System.Type element_type, bool owned, bool elements_owned) : base (raw, element_type, false, false) {} + + public SList (object[] members, System.Type element_type, bool owned, bool elements_owned) : this (IntPtr.Zero, element_type, owned, elements_owned) + { + foreach (object o in members) + Append (o); + } + + public SList (Array members, System.Type element_type, bool owned, bool elements_owned) : this (IntPtr.Zero, element_type, owned, elements_owned) + { + foreach (object o in members) + Append (o); + } + } +} diff --git a/gstreamer-sharp/glib-sharp/Signal.cs b/gstreamer-sharp/glib-sharp/Signal.cs new file mode 100644 index 0000000000..7dc3dbbe10 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Signal.cs @@ -0,0 +1,421 @@ +// GLib.Signal.cs - signal marshaling class +// +// Authors: Mike Kestner +// AndrĂ©s G. Aragoneses +// +// Copyright (c) 2005,2008 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.Runtime.InteropServices; + + [Flags] + public enum ConnectFlags { + After = 1 << 0, + Swapped = 1 << 1, + } + + public class Signal { + + [Flags] + public enum Flags { + RunFirst = 1 << 0, + RunLast = 1 << 1, + RunCleanup = 1 << 2, + NoRecurse = 1 << 3, + Detailed = 1 << 4, + Action = 1 << 5, + NoHooks = 1 << 6 + } + + [StructLayout (LayoutKind.Sequential)] + public struct InvocationHint { + public uint signal_id; + public uint detail; + public Flags run_type; + } + + [StructLayout (LayoutKind.Sequential)] + struct Query { + public uint signal_id; + public IntPtr signal_name; + public IntPtr itype; + public Flags signal_flags; + public IntPtr return_type; + public uint n_params; + public IntPtr param_types; + } + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + public delegate bool EmissionHookNative (ref InvocationHint hint, uint n_pvals, IntPtr pvals, IntPtr data); + + public delegate bool EmissionHook (InvocationHint ihint, object[] inst_and_param_values); + + public class EmissionHookMarshaler { + + EmissionHook handler; + EmissionHookNative cb; + IntPtr user_data; + GCHandle gch; + + public EmissionHookMarshaler (EmissionHook handler) + { + this.handler = handler; + cb = new EmissionHookNative (NativeCallback); + gch = GCHandle.Alloc (this); + } + + public EmissionHookMarshaler (EmissionHookNative callback, IntPtr user_data) + { + cb = callback; + this.user_data = user_data; + handler = new EmissionHook (NativeInvoker); + } + + bool NativeCallback (ref InvocationHint hint, uint n_pvals, IntPtr pvals_ptr, IntPtr data) + { + object[] pvals = new object [n_pvals]; + for (int i = 0; i < n_pvals; i++) { + IntPtr p = new IntPtr ((long) pvals_ptr + i * Marshal.SizeOf (typeof (Value))); + Value v = (Value) Marshal.PtrToStructure (p, typeof (Value)); + pvals [i] = v.Val; + } + bool result = handler (hint, pvals); + if (!result) + gch.Free (); + return result; + } + + public EmissionHookNative Callback { + get { + return cb; + } + } + + bool NativeInvoker (InvocationHint ihint, object[] pvals) + { + int val_sz = Marshal.SizeOf (typeof (Value)); + IntPtr buf = Marshal.AllocHGlobal (pvals.Length * val_sz); + Value[] vals = new Value [pvals.Length]; + for (int i = 0; i < pvals.Length; i++) { + vals [i] = new Value (pvals [i]); + IntPtr p = new IntPtr ((long) buf + i * val_sz); + Marshal.StructureToPtr (vals [i], p, false); + } + bool result = cb (ref ihint, (uint) pvals.Length, buf, user_data); + foreach (Value v in vals) + v.Dispose (); + Marshal.FreeHGlobal (buf); + return result; + } + + public EmissionHook Invoker { + get { + return handler; + } + } + } + + ToggleRef tref; + string name; + Type args_type; + SignalClosure before_closure; + SignalClosure after_closure; + Delegate marshaler; + + private Signal (GLib.Object obj, string signal_name, Delegate marshaler) + { + tref = obj.ToggleRef; + name = signal_name; + tref.Signals [name] = this; + this.marshaler = marshaler; + } + + private Signal (GLib.Object obj, string signal_name, Type args_type) + { + tref = obj.ToggleRef; + name = signal_name; + this.args_type = args_type; + tref.Signals [name] = this; + } + + internal void Free () + { + if (before_closure != null) + before_closure.Dispose (); + if (after_closure != null) + after_closure.Dispose (); + GC.SuppressFinalize (this); + } + + void ClosureDisposedCB (object o, EventArgs args) + { + if (o == before_closure) { + before_closure.Disposed -= new EventHandler (ClosureDisposedHandler); + before_closure.Invoked -= new ClosureInvokedHandler (ClosureInvokedCB); + if (tref.Target != null) + tref.Target.BeforeSignals.Remove (name); + before_closure = null; + } else if (o == after_closure) { + after_closure.Disposed -= new EventHandler (ClosureDisposedHandler); + after_closure.Invoked -= new ClosureInvokedHandler (ClosureInvokedCB); + if (tref.Target != null) + tref.Target.AfterSignals.Remove (name); + after_closure = null; + } + + if (before_closure == null && after_closure == null) + tref.Signals.Remove (name); + } + + EventHandler closure_disposed_cb; + EventHandler ClosureDisposedHandler { + get { + if (closure_disposed_cb == null) + closure_disposed_cb = new EventHandler (ClosureDisposedCB); + return closure_disposed_cb; + } + } + + void ClosureInvokedCB (object o, ClosureInvokedArgs args) + { + Delegate handler; + if (o == before_closure) + handler = args.Target.BeforeSignals [name] as Delegate; + else + handler = args.Target.AfterSignals [name] as Delegate; + + if (handler != null) + handler.DynamicInvoke (new object[] {args.Target, args.Args}); + } + + ClosureInvokedHandler closure_invoked_cb; + ClosureInvokedHandler ClosureInvokedHandler { + get { + if (closure_invoked_cb == null) + closure_invoked_cb = new ClosureInvokedHandler (ClosureInvokedCB); + return closure_invoked_cb; + } + } + + public static Signal Lookup (GLib.Object obj, string name) + { + return Lookup (obj, name, typeof (EventArgs)); + } + + public static Signal Lookup (GLib.Object obj, string name, Delegate marshaler) + { + Signal result = obj.ToggleRef.Signals [name] as Signal; + if (result == null) + result = new Signal (obj, name, marshaler); + return result; + } + + public static Signal Lookup (GLib.Object obj, string name, Type args_type) + { + Signal result = obj.ToggleRef.Signals [name] as Signal; + if (result == null) + result = new Signal (obj, name, args_type); + return result; + } + + + public Delegate Handler { + get { + InvocationHint hint = (InvocationHint) Marshal.PtrToStructure (g_signal_get_invocation_hint (tref.Handle), typeof (InvocationHint)); + if (hint.run_type == Flags.RunFirst) + return tref.Target.BeforeSignals [name] as Delegate; + else + return tref.Target.AfterSignals [name] as Delegate; + } + } + + public void AddDelegate (Delegate d) + { + if (args_type == null) + args_type = d.Method.GetParameters ()[1].ParameterType; + + if (d.Method.IsDefined (typeof (ConnectBeforeAttribute), false)) { + tref.Target.BeforeSignals [name] = Delegate.Combine (tref.Target.BeforeSignals [name] as Delegate, d); + if (before_closure == null) { + if (marshaler == null) + before_closure = new SignalClosure (tref.Handle, name, args_type); + else + before_closure = new SignalClosure (tref.Handle, name, marshaler, this); + before_closure.Disposed += ClosureDisposedHandler; + before_closure.Invoked += ClosureInvokedHandler; + before_closure.Connect (false); + } + } else { + tref.Target.AfterSignals [name] = Delegate.Combine (tref.Target.AfterSignals [name] as Delegate, d); + if (after_closure == null) { + if (marshaler == null) + after_closure = new SignalClosure (tref.Handle, name, args_type); + else + after_closure = new SignalClosure (tref.Handle, name, marshaler, this); + after_closure.Disposed += ClosureDisposedHandler; + after_closure.Invoked += ClosureInvokedHandler; + after_closure.Connect (true); + } + } + } + + public void RemoveDelegate (Delegate d) + { + if (tref.Target == null) + return; + + if (d.Method.IsDefined (typeof (ConnectBeforeAttribute), false)) { + tref.Target.BeforeSignals [name] = Delegate.Remove (tref.Target.BeforeSignals [name] as Delegate, d); + if (tref.Target.BeforeSignals [name] == null && before_closure != null) { + before_closure.Dispose (); + before_closure = null; + } + } else { + tref.Target.AfterSignals [name] = Delegate.Remove (tref.Target.AfterSignals [name] as Delegate, d); + if (tref.Target.AfterSignals [name] == null && after_closure != null) { + after_closure.Dispose (); + after_closure = null; + } + } + } + + // format: children-changed::add + private static void ParseSignalDetail (string signal_detail, out string signal_name, out uint gquark) + { + //can't use String.Split because it doesn't accept a string arg (only char) in the 1.x profile + int link_pos = signal_detail.IndexOf ("::"); + if (link_pos < 0) { + gquark = 0; + signal_name = signal_detail; + } else if (link_pos == 0) { + throw new FormatException ("Invalid detailed signal: " + signal_detail); + } else { + signal_name = signal_detail.Substring (0, link_pos); + gquark = GetGQuarkFromString (signal_detail.Substring (link_pos + 2)); + } + } + + public static object Emit (GLib.Object instance, string detailed_signal, params object[] args) + { + uint gquark, signal_id; + string signal_name; + ParseSignalDetail (detailed_signal, out signal_name, out gquark); + signal_id = GetSignalId (signal_name, instance); + if (signal_id <= 0) + throw new ArgumentException ("Invalid signal name: " + signal_name); + GLib.Value[] vals = new GLib.Value [args.Length + 1]; + GLib.ValueArray inst_and_params = new GLib.ValueArray ((uint) args.Length + 1); + + vals [0] = new GLib.Value (instance); + inst_and_params.Append (vals [0]); + for (int i = 1; i < vals.Length; i++) { + vals [i] = new GLib.Value (args [i - 1]); + inst_and_params.Append (vals [i]); + } + + object ret_obj = null; + Query query; + g_signal_query (signal_id, out query); + if (query.return_type != GType.None.Val) { + GLib.Value ret = GLib.Value.Empty; + g_signal_emitv (inst_and_params.ArrayPtr, signal_id, gquark, ref ret); + ret_obj = ret.Val; + ret.Dispose (); + } else + g_signal_emitv (inst_and_params.ArrayPtr, signal_id, gquark, IntPtr.Zero); + + foreach (GLib.Value val in vals) + val.Dispose (); + + return ret_obj; + } + + private static uint GetGQuarkFromString (string str) { + IntPtr native_string = GLib.Marshaller.StringToPtrGStrdup (str); + uint ret = g_quark_from_string (native_string); + GLib.Marshaller.Free (native_string); + return ret; + } + + private static uint GetSignalId (string signal_name, GLib.Object obj) + { + IntPtr typeid = GType.ValFromInstancePtr (obj.Handle); + return GetSignalId (signal_name, typeid); + } + + private static uint GetSignalId (string signal_name, IntPtr typeid) + { + IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (signal_name); + uint signal_id = g_signal_lookup (native_name, typeid); + GLib.Marshaller.Free (native_name); + return signal_id; + } + + public static ulong AddEmissionHook (string detailed_signal, GLib.GType type, EmissionHook handler_func) + { + uint gquark; + string signal_name; + ParseSignalDetail (detailed_signal, out signal_name, out gquark); + uint signal_id = GetSignalId (signal_name, type.Val); + if (signal_id <= 0) + throw new Exception ("Invalid signal name: " + signal_name); + return g_signal_add_emission_hook (signal_id, gquark, new EmissionHookMarshaler (handler_func).Callback, IntPtr.Zero, IntPtr.Zero); + } + + internal static void OverrideDefaultHandler (GType gtype, string name, Delegate cb) + { + IntPtr closure = g_cclosure_new (cb, IntPtr.Zero, IntPtr.Zero); + gtype.EnsureClass (); + uint id = GetSignalId (name, gtype.Val); + g_signal_override_class_closure (id, gtype.Val, closure); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_cclosure_new (Delegate cb, IntPtr data, IntPtr notify); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_signal_get_invocation_hint (IntPtr instance); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_signal_emitv (IntPtr instance_and_params, uint signal_id, uint gquark_detail, ref GLib.Value return_value); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_signal_emitv (IntPtr instance_and_params, uint signal_id, uint gquark_detail, IntPtr return_value); + + [DllImport("libgobject-2.0-0.dll")] + static extern uint g_signal_lookup (IntPtr name, IntPtr itype); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_signal_override_class_closure (uint id, IntPtr gtype, IntPtr closure); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_signal_query (uint signal_id, out Query query); + + //better not to expose g_quark_from_static_string () due to memory allocation issues + [DllImport("libglib-2.0-0.dll")] + static extern uint g_quark_from_string (IntPtr str); + + [DllImport("libgobject-2.0-0.dll")] + static extern ulong g_signal_add_emission_hook (uint signal_id, uint gquark_detail, EmissionHookNative hook_func, IntPtr hook_data, IntPtr data_destroy); + + } +} + diff --git a/gstreamer-sharp/glib-sharp/SignalArgs.cs b/gstreamer-sharp/glib-sharp/SignalArgs.cs new file mode 100644 index 0000000000..7ef9ad0b8d --- /dev/null +++ b/gstreamer-sharp/glib-sharp/SignalArgs.cs @@ -0,0 +1,68 @@ +// GLib.SignalArgs.cs - Signal argument class implementation +// +// Author: Mike Kestner +// +// Copyright (c) 2001 Mike Kestner +// Copyright (c) 2004 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + using System; + using System.Collections; + + public class SignalArgs : EventArgs { + + private object _ret; + private object[] _args; + + public SignalArgs() + { + _ret = null; + _args = null; + } + + public SignalArgs(object retval) + { + _ret = retval; + _args = null; + } + + public SignalArgs(object retval, object[] args) + { + _ret = retval; + _args = args; + } + + public object[] Args { + get { + return _args; + } + set { + _args = value; + } + } + + public object RetVal { + get { + return _ret; + } + set { + _ret = value; + } + } + } +} diff --git a/gstreamer-sharp/glib-sharp/SignalAttribute.cs b/gstreamer-sharp/glib-sharp/SignalAttribute.cs new file mode 100644 index 0000000000..66adbbb3c9 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/SignalAttribute.cs @@ -0,0 +1,47 @@ +// SignalAttribute.cs +// +// Author: +// Ricardo Fernández Pascual +// +// Copyright (c) Ricardo Fernández Pascual +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + + [Serializable] + [AttributeUsage (AttributeTargets.Event, Inherited=false)] + public sealed class SignalAttribute : Attribute + { + private string cname; + + public SignalAttribute (string cname) + { + this.cname = cname; + } + + private SignalAttribute () {} + + public string CName + { + get { + return cname; + } + } + } +} diff --git a/gstreamer-sharp/glib-sharp/SignalCallback.cs b/gstreamer-sharp/glib-sharp/SignalCallback.cs new file mode 100644 index 0000000000..1daa04dcb5 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/SignalCallback.cs @@ -0,0 +1,106 @@ +// GLib.SignalCallback.cs - Signal callback base class implementation +// +// Authors: Mike Kestner +// +// Copyright (c) 2001 Mike Kestner +// Copyright (c) 2004 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + using System; + using System.Collections; + using System.Runtime.InteropServices; + + [Obsolete ("Replaced by GLib.Signal.")] + public abstract class SignalCallback : IDisposable { + + // A counter used to produce unique keys for instances. + protected static int _NextKey = 0; + + // Hashtable containing refs to all current instances. + protected static Hashtable _Instances = new Hashtable (); + + // protected instance members + protected GLib.Object _obj; + protected Delegate _handler; + protected int _key; + protected System.Type _argstype; + protected uint _HandlerID; + + protected SignalCallback (GLib.Object obj, Delegate eh, System.Type argstype) + { + _key = _NextKey++; + _obj = obj; + _handler = eh; + _argstype = argstype; + _Instances [_key] = this; + } + + public void AddDelegate (Delegate d) + { + _handler = Delegate.Combine (_handler, d); + } + + public void RemoveDelegate (Delegate d) + { + _handler = Delegate.Remove (_handler, d); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern uint g_signal_connect_data(IntPtr obj, IntPtr name, Delegate cb, int key, IntPtr p, int flags); + + protected void Connect (string name, Delegate cb, int flags) + { + IntPtr native_name = Marshaller.StringToPtrGStrdup (name); + _HandlerID = g_signal_connect_data(_obj.Handle, native_name, cb, _key, new IntPtr(0), flags); + Marshaller.Free (native_name); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_signal_handler_disconnect (IntPtr instance, uint handler); + + [DllImport("libgobject-2.0-0.dll")] + static extern bool g_signal_handler_is_connected (IntPtr instance, uint handler); + + protected void Disconnect () + { + if (g_signal_handler_is_connected (_obj.Handle, _HandlerID)) + g_signal_handler_disconnect (_obj.Handle, _HandlerID); + } + + public void Dispose () + { + Dispose (true); + GC.SuppressFinalize (this); + } + + protected virtual void Dispose (bool disposing) + { + if (disposing) { + _obj = null; + _handler = null; + _argstype = null; + } + } + + ~SignalCallback () + { + Dispose (false); + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/SignalClosure.cs b/gstreamer-sharp/glib-sharp/SignalClosure.cs new file mode 100644 index 0000000000..2fd4cfb14d --- /dev/null +++ b/gstreamer-sharp/glib-sharp/SignalClosure.cs @@ -0,0 +1,227 @@ +// SignalClosure.cs - signal marshaling class +// +// Authors: Mike Kestner +// +// Copyright (c) 2008 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.Runtime.InteropServices; + + internal class ClosureInvokedArgs : EventArgs { + + EventArgs args; + GLib.Object obj; + object result; + + public ClosureInvokedArgs (GLib.Object obj, EventArgs args) + { + this.obj = obj; + this.args = args; + } + + public EventArgs Args { + get { + return args; + } + } + + public GLib.Object Target { + get { + return obj; + } + } + } + + struct GClosure { + long fields; + IntPtr marshaler; + IntPtr data; + IntPtr notifiers; + } + + internal delegate void ClosureInvokedHandler (object o, ClosureInvokedArgs args); + + internal class SignalClosure : IDisposable { + + IntPtr handle; + IntPtr raw_closure; + string name; + uint id = UInt32.MaxValue; + System.Type args_type; + Delegate custom_marshaler; + GCHandle gch; + + static Hashtable closures = new Hashtable (); + + public SignalClosure (IntPtr obj, string signal_name, System.Type args_type) + { + raw_closure = g_closure_new_simple (Marshal.SizeOf (typeof (GClosure)), IntPtr.Zero); + g_closure_set_marshal (raw_closure, Marshaler); + g_closure_add_finalize_notifier (raw_closure, IntPtr.Zero, Notify); + closures [raw_closure] = this; + handle = obj; + name = signal_name; + this.args_type = args_type; + } + + public SignalClosure (IntPtr obj, string signal_name, Delegate custom_marshaler, Signal signal) + { + gch = GCHandle.Alloc (signal); + raw_closure = g_cclosure_new (custom_marshaler, (IntPtr) gch, Notify); + closures [raw_closure] = this; + handle = obj; + name = signal_name; + this.custom_marshaler = custom_marshaler; + } + + public event EventHandler Disposed; + public event ClosureInvokedHandler Invoked; + + public void Connect (bool is_after) + { + IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name); + id = g_signal_connect_closure (handle, native_name, raw_closure, is_after); + GLib.Marshaller.Free (native_name); + } + + public void Disconnect () + { + if (id != UInt32.MaxValue && g_signal_handler_is_connected (handle, id)) + g_signal_handler_disconnect (handle, id); + } + + public void Dispose () + { + Disconnect (); + closures.Remove (raw_closure); + if (custom_marshaler != null) + gch.Free (); + custom_marshaler = null; + if (Disposed != null) + Disposed (this, EventArgs.Empty); + GC.SuppressFinalize (this); + } + + public void Invoke (ClosureInvokedArgs args) + { + if (Invoked == null) + return; + Invoked (this, args); + } + + static ClosureMarshal marshaler; + static ClosureMarshal Marshaler { + get { + if (marshaler == null) + marshaler = new ClosureMarshal (MarshalCallback); + return marshaler; + } + } + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate void ClosureMarshal (IntPtr closure, IntPtr return_val, uint n_param_vals, IntPtr param_values, IntPtr invocation_hint, IntPtr marshal_data); + + static void MarshalCallback (IntPtr raw_closure, IntPtr return_val, uint n_param_vals, IntPtr param_values, IntPtr invocation_hint, IntPtr marshal_data) + { + string message = String.Empty; + + try { + SignalClosure closure = closures [raw_closure] as SignalClosure; + message = "Marshaling " + closure.name + " signal"; + Value objval = (Value) Marshal.PtrToStructure (param_values, typeof (Value)); + GLib.Object __obj = objval.Val as GLib.Object; + if (__obj == null) + return; + + if (closure.args_type == typeof (EventArgs)) { + closure.Invoke (new ClosureInvokedArgs (__obj, EventArgs.Empty)); + return; + } + + SignalArgs args = Activator.CreateInstance (closure.args_type, new object [0]) as SignalArgs; + args.Args = new object [n_param_vals - 1]; + GLib.Value[] vals = new GLib.Value [n_param_vals - 1]; + for (int i = 1; i < n_param_vals; i++) { + IntPtr ptr = new IntPtr (param_values.ToInt64 () + i * Marshal.SizeOf (typeof (Value))); + vals [i - 1] = (Value) Marshal.PtrToStructure (ptr, typeof (Value)); + args.Args [i - 1] = vals [i - 1].Val; + } + ClosureInvokedArgs ci_args = new ClosureInvokedArgs (__obj, args); + closure.Invoke (ci_args); + for (int i = 1; i < n_param_vals; i++) { + vals [i - 1].Update (args.Args [i - 1]); + IntPtr ptr = new IntPtr (param_values.ToInt64 () + i * Marshal.SizeOf (typeof (Value))); + Marshal.StructureToPtr (vals [i - 1], ptr, false); + } + if (return_val == IntPtr.Zero || args.RetVal == null) + return; + + Value ret = (Value) Marshal.PtrToStructure (return_val, typeof (Value)); + ret.Val = args.RetVal; + Marshal.StructureToPtr (ret, return_val, false); + } catch (Exception e) { + Console.WriteLine (message); + ExceptionManager.RaiseUnhandledException (e, false); + } + } + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate void ClosureNotify (IntPtr data, IntPtr closure); + + static void NotifyCallback (IntPtr data, IntPtr raw_closure) + { + SignalClosure closure = closures [raw_closure] as SignalClosure; + if (closure != null) + closure.Dispose (); + } + + static ClosureNotify notify_handler; + static ClosureNotify Notify { + get { + if (notify_handler == null) + notify_handler = new ClosureNotify (NotifyCallback); + return notify_handler; + } + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_cclosure_new (Delegate cb, IntPtr user_data, ClosureNotify notify); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_closure_new_simple (int closure_size, IntPtr dummy); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_closure_set_marshal (IntPtr closure, ClosureMarshal marshaler); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_closure_add_finalize_notifier (IntPtr closure, IntPtr dummy, ClosureNotify notify); + + [DllImport("libgobject-2.0-0.dll")] + static extern uint g_signal_connect_closure (IntPtr obj, IntPtr name, IntPtr closure, bool is_after); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_signal_handler_disconnect (IntPtr instance, uint handler); + + [DllImport("libgobject-2.0-0.dll")] + static extern bool g_signal_handler_is_connected (IntPtr instance, uint handler); + } +} + diff --git a/gstreamer-sharp/glib-sharp/Source.cs b/gstreamer-sharp/glib-sharp/Source.cs new file mode 100644 index 0000000000..afbd020f3c --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Source.cs @@ -0,0 +1,62 @@ +// GLib.Source.cs - Source class implementation +// +// Author: Duncan Mak +// +// Copyright (c) 2002 Mike Kestner +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.Runtime.InteropServices; + + public delegate bool GSourceFunc (); + + // + // Base class for IdleProxy and TimeoutProxy + // + internal class SourceProxy { + internal Delegate real_handler; + internal Delegate proxy_handler; + internal uint ID; + + internal void Remove () + { + lock (Source.source_handlers) + Source.source_handlers.Remove (ID); + real_handler = null; + proxy_handler = null; + } + } + + public class Source { + private Source () {} + + internal static Hashtable source_handlers = new Hashtable (); + + [DllImport("libglib-2.0-0.dll")] + static extern bool g_source_remove (uint tag); + + public static bool Remove (uint tag) + { + lock (Source.source_handlers) + source_handlers.Remove (tag); + return g_source_remove (tag); + } + } +} diff --git a/gstreamer-sharp/glib-sharp/Spawn.cs b/gstreamer-sharp/glib-sharp/Spawn.cs new file mode 100644 index 0000000000..32b78d21b2 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Spawn.cs @@ -0,0 +1,216 @@ +// glib/Spawn.cs : Spawn g_spawn API wrapper +// +// Author: Mike Kestner +// +// Copyright (c) 2007 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + public enum SpawnError { + Fork, + Read, + Chdir, + Acces, + Perm, + TooBig, + NoExec, + NameTooLong, + NoEnt, + NoMem, + NotDir, + Loop, + TxtBusy, + IO, + NFile, + MFile, + Inval, + IsDir, + LibBad, + Failed, + } + + [Flags] + public enum SpawnFlags { + LeaveDescriptorsOpen = 1 << 0, + DoNotReapChild = 1 << 1, + SearchPath = 1 << 2, + StdoutToDevNull = 1 << 3, + StderrToDevNull = 1 << 4, + ChildInheritsStdin = 1 << 5, + FileAndArgvZero = 1 << 6, + } + + public delegate void SpawnChildSetupFunc (); + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void SpawnChildSetupFuncNative (IntPtr gch); + + internal class SpawnChildSetupWrapper { + + SpawnChildSetupFunc handler; + + public SpawnChildSetupWrapper (SpawnChildSetupFunc handler) + { + if (handler == null) + return; + + this.handler = handler; + Data = (IntPtr) GCHandle.Alloc (this); + NativeCallback = new SpawnChildSetupFuncNative (InvokeHandler); + } + + public IntPtr Data; + public SpawnChildSetupFuncNative NativeCallback; + + static void InvokeHandler (IntPtr data) + { + if (data == IntPtr.Zero) + return; + GCHandle gch = (GCHandle) data; + (gch.Target as SpawnChildSetupWrapper).handler (); + gch.Free (); + } + } + + public class Process { + + public const int IgnorePipe = Int32.MaxValue; + public const int RequestPipe = 0; + + long pid; + + private Process (int pid) + { + this.pid = pid; + } + + [DllImport ("libglib-2.0-0.dll")] + static extern void g_spawn_close_pid (int pid); + + public void Close () + { + g_spawn_close_pid ((int) pid); + } + + [DllImport ("libglib-2.0-0.dll")] + static extern bool g_spawn_async (IntPtr dir, IntPtr[] argv, IntPtr[] envp, int flags, SpawnChildSetupFuncNative func, IntPtr data, out int pid, out IntPtr error); + + public static bool SpawnAsync (string working_directory, string[] argv, string[] envp, SpawnFlags flags, SpawnChildSetupFunc child_setup, out Process child_process) + { + int pid; + IntPtr error; + IntPtr native_dir = Marshaller.StringToPtrGStrdup (working_directory); + IntPtr[] native_argv = Marshaller.StringArrayToNullTermPointer (argv); + IntPtr[] native_envp = Marshaller.StringArrayToNullTermPointer (envp); + SpawnChildSetupWrapper wrapper = new SpawnChildSetupWrapper (child_setup); + bool result = g_spawn_async (native_dir, native_argv, native_envp, (int) flags, wrapper.NativeCallback, wrapper.Data, out pid, out error); + child_process = new Process (pid); + Marshaller.Free (native_dir); + Marshaller.Free (native_argv); + Marshaller.Free (native_envp); + if (error != IntPtr.Zero) throw new GLib.GException (error); + return result; + } + + [DllImport ("libglib-2.0-0.dll")] + static extern bool g_spawn_async_with_pipes (IntPtr dir, IntPtr[] argv, IntPtr[] envp, int flags, SpawnChildSetupFuncNative func, IntPtr data, out int pid, IntPtr stdin, IntPtr stdout, IntPtr stderr, out IntPtr error); + + public static bool SpawnAsyncWithPipes (string working_directory, string[] argv, string[] envp, SpawnFlags flags, SpawnChildSetupFunc child_setup, out Process child_process, ref int stdin, ref int stdout, ref int stderr) + { + int pid; + IntPtr error; + IntPtr native_dir = Marshaller.StringToPtrGStrdup (working_directory); + IntPtr[] native_argv = Marshaller.StringArrayToNullTermPointer (argv); + IntPtr[] native_envp = Marshaller.StringArrayToNullTermPointer (envp); + SpawnChildSetupWrapper wrapper = new SpawnChildSetupWrapper (child_setup); + IntPtr in_ptr = stdin == IgnorePipe ? IntPtr.Zero : Marshal.AllocHGlobal (4); + IntPtr out_ptr = stdout == IgnorePipe ? IntPtr.Zero : Marshal.AllocHGlobal (4); + IntPtr err_ptr = stderr == IgnorePipe ? IntPtr.Zero : Marshal.AllocHGlobal (4); + bool result = g_spawn_async_with_pipes (native_dir, native_argv, native_envp, (int) flags, wrapper.NativeCallback, wrapper.Data, out pid, in_ptr, out_ptr, err_ptr, out error); + child_process = new Process (pid); + if (in_ptr != IntPtr.Zero) { + stdin = Marshal.ReadInt32 (in_ptr); + Marshal.FreeHGlobal (in_ptr); + } + if (out_ptr != IntPtr.Zero) { + stdout = Marshal.ReadInt32 (out_ptr); + Marshal.FreeHGlobal (out_ptr); + } + if (err_ptr != IntPtr.Zero) { + stderr = Marshal.ReadInt32 (err_ptr); + Marshal.FreeHGlobal (err_ptr); + } + Marshaller.Free (native_dir); + Marshaller.Free (native_argv); + Marshaller.Free (native_envp); + if (error != IntPtr.Zero) throw new GLib.GException (error); + return result; + } + + [DllImport ("libglib-2.0-0.dll")] + static extern bool g_spawn_sync (IntPtr dir, IntPtr[] argv, IntPtr[] envp, int flags, SpawnChildSetupFuncNative func, IntPtr data, out IntPtr stdout, out IntPtr stderr, out int exit_status, out IntPtr error); + + public static bool SpawnSync (string working_directory, string[] argv, string[] envp, SpawnFlags flags, SpawnChildSetupFunc child_setup, out string stdout, out string stderr, out int exit_status) + { + IntPtr native_stdout, native_stderr, error; + IntPtr native_dir = Marshaller.StringToPtrGStrdup (working_directory); + IntPtr[] native_argv = Marshaller.StringArrayToNullTermPointer (argv); + IntPtr[] native_envp = Marshaller.StringArrayToNullTermPointer (envp); + SpawnChildSetupWrapper wrapper = new SpawnChildSetupWrapper (child_setup); + bool result = g_spawn_sync (native_dir, native_argv, native_envp, (int) flags, wrapper.NativeCallback, wrapper.Data, out native_stdout, out native_stderr, out exit_status, out error); + Marshaller.Free (native_dir); + Marshaller.Free (native_argv); + Marshaller.Free (native_envp); + stdout = Marshaller.PtrToStringGFree (native_stdout); + stderr = Marshaller.PtrToStringGFree (native_stderr); + if (error != IntPtr.Zero) throw new GLib.GException (error); + return result; + } + + [DllImport ("libglib-2.0-0.dll")] + static extern bool g_spawn_command_line_async (IntPtr cmdline, out IntPtr error); + + public static bool SpawnCommandLineAsync (string command_line) + { + IntPtr error; + IntPtr native_cmd = Marshaller.StringToPtrGStrdup (command_line); + bool result = g_spawn_command_line_async (native_cmd, out error); + Marshaller.Free (native_cmd); + if (error != IntPtr.Zero) throw new GLib.GException (error); + return result; + } + + [DllImport ("libglib-2.0-0.dll")] + static extern bool g_spawn_command_line_sync (IntPtr cmdline, out IntPtr stdout, out IntPtr stderr, out int exit_status, out IntPtr error); + + public static bool SpawnCommandLineSync (string command_line, out string stdout, out string stderr, out int exit_status) + { + IntPtr error, native_stdout, native_stderr; + IntPtr native_cmd = Marshaller.StringToPtrGStrdup (command_line); + bool result = g_spawn_command_line_sync (native_cmd, out native_stdout, out native_stderr, out exit_status, out error); + Marshaller.Free (native_cmd); + stdout = Marshaller.PtrToStringGFree (native_stdout); + stderr = Marshaller.PtrToStringGFree (native_stderr); + if (error != IntPtr.Zero) throw new GLib.GException (error); + return result; + } + } +} diff --git a/gstreamer-sharp/glib-sharp/Thread.cs b/gstreamer-sharp/glib-sharp/Thread.cs new file mode 100644 index 0000000000..25097e6fa1 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Thread.cs @@ -0,0 +1,49 @@ +// Thread.cs - thread awareness +// +// Author: Alp Toker +// +// Copyright (c) 2002 Alp Toker +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib +{ + using System; + using System.Runtime.InteropServices; + + public class Thread + { + private Thread () {} + + [DllImport("libgthread-2.0-0.dll")] + static extern void g_thread_init (IntPtr i); + + public static void Init () + { + g_thread_init (IntPtr.Zero); + } + + [DllImport("glibsharpglue-2")] + static extern bool glibsharp_g_thread_supported (); + + public static bool Supported + { + get { + return glibsharp_g_thread_supported (); + } + } + } +} diff --git a/gstreamer-sharp/glib-sharp/Timeout.cs b/gstreamer-sharp/glib-sharp/Timeout.cs new file mode 100644 index 0000000000..9cecc01cdb --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Timeout.cs @@ -0,0 +1,135 @@ +// GLib.Timeout.cs - Timeout class implementation +// +// Author(s): +// Mike Kestner +// Stephane Delcroix +// +// Copyright (c) 2002 Mike Kestner +// Copyright (c) 2009 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.Runtime.InteropServices; + + public delegate bool TimeoutHandler (); + + public class Timeout { + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate bool TimeoutHandlerInternal (); + + internal class TimeoutProxy : SourceProxy { + public TimeoutProxy (TimeoutHandler real) + { + real_handler = real; + proxy_handler = new TimeoutHandlerInternal (Handler); + } + + public bool Handler () + { + try { + TimeoutHandler timeout_handler = (TimeoutHandler) real_handler; + + bool cont = timeout_handler (); + if (!cont) + Remove (); + return cont; + } catch (Exception e) { + ExceptionManager.RaiseUnhandledException (e, false); + } + return false; + } + } + + private Timeout () {} + [DllImport("libglib-2.0-0.dll")] + static extern uint g_timeout_add (uint interval, TimeoutHandlerInternal d, IntPtr data); + + public static uint Add (uint interval, TimeoutHandler hndlr) + { + TimeoutProxy p = new TimeoutProxy (hndlr); + + p.ID = g_timeout_add (interval, (TimeoutHandlerInternal) p.proxy_handler, IntPtr.Zero); + lock (Source.source_handlers) + Source.source_handlers [p.ID] = p; + + return p.ID; + } + + [DllImport("libglib-2.0-0.dll")] + static extern uint g_timeout_add_full (int priority, uint interval, TimeoutHandlerInternal d, IntPtr data, DestroyNotify notify); + + public static uint Add (uint interval, TimeoutHandler hndlr, Priority priority) + { + TimeoutProxy p = new TimeoutProxy (hndlr); + + p.ID = g_timeout_add_full ((int)priority, interval, (TimeoutHandlerInternal) p.proxy_handler, IntPtr.Zero, null); + lock (Source.source_handlers) + Source.source_handlers [p.ID] = p; + + return p.ID; + } + + [DllImport("libglib-2.0-0.dll")] + static extern uint g_timeout_add_seconds (uint interval, TimeoutHandlerInternal d, IntPtr data); + + public static uint AddSeconds (uint interval, TimeoutHandler hndlr) + { + TimeoutProxy p = new TimeoutProxy (hndlr); + + p.ID = g_timeout_add_seconds (interval, (TimeoutHandlerInternal) p.proxy_handler, IntPtr.Zero); + lock (Source.source_handlers) + Source.source_handlers [p.ID] = p; + + return p.ID; + } + + public static void Remove (uint id) + { + Source.Remove (id); + } + + [DllImport("libglib-2.0-0.dll")] + static extern bool g_source_remove_by_funcs_user_data (Delegate d, IntPtr data); + + public static bool Remove (TimeoutHandler hndlr) + { + bool result = false; + ArrayList keys = new ArrayList (); + + lock (Source.source_handlers) { + foreach (uint code in Source.source_handlers.Keys) { + TimeoutProxy p = Source.source_handlers [code] as TimeoutProxy; + + if (p != null && p.real_handler == hndlr) { + keys.Add (code); + result = g_source_remove_by_funcs_user_data (p.proxy_handler, IntPtr.Zero); + } + } + + foreach (object key in keys) + Source.source_handlers.Remove (key); + } + + return result; + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/ToggleRef.cs b/gstreamer-sharp/glib-sharp/ToggleRef.cs new file mode 100644 index 0000000000..1a16c86233 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/ToggleRef.cs @@ -0,0 +1,159 @@ +// GLib.ToggleRef.cs - GLib ToggleRef class implementation +// +// Author: Mike Kestner +// +// Copyright 2007 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.Runtime.InteropServices; + + internal class ToggleRef { + + bool hardened; + IntPtr handle; + object reference; + GCHandle gch; + Hashtable signals; + + public ToggleRef (GLib.Object target) + { + handle = target.Handle; + gch = GCHandle.Alloc (this); + reference = target; + g_object_add_toggle_ref (target.Handle, ToggleNotifyCallback, (IntPtr) gch); + g_object_unref (target.Handle); + } + + public bool IsAlive { + get { + if (reference is WeakReference) { + WeakReference weak = reference as WeakReference; + return weak.IsAlive; + } else if (reference == null) + return false; + return true; + } + } + + public IntPtr Handle { + get { + return handle; + } + } + + public Hashtable Signals { + get { + if (signals == null) + signals = new Hashtable (); + return signals; + } + } + + public GLib.Object Target { + get { + if (reference == null) + return null; + else if (reference is GLib.Object) + return reference as GLib.Object; + + WeakReference weak = reference as WeakReference; + return weak.Target as GLib.Object; + } + } + + public void Free () + { + Signal[] signals = new Signal [Signals.Count]; + Signals.Values.CopyTo (signals, 0); + foreach (Signal s in signals) + s.Free (); + if (hardened) + g_object_unref (handle); + else + g_object_remove_toggle_ref (handle, ToggleNotifyCallback, (IntPtr) gch); + reference = null; + gch.Free (); + } + + internal void Harden () + { + // Added for the benefit of GnomeProgram. It releases a final ref in + // an atexit handler which causes toggle ref notifications to occur after + // our delegates are gone, so we need a mechanism to override the + // notifications. This method effectively leaks all objects which invoke it, + // but since it is only used by Gnome.Program, which is a singleton object + // with program duration persistence, who cares. + + g_object_ref (handle); + g_object_remove_toggle_ref (handle, ToggleNotifyCallback, (IntPtr) gch); + if (reference is WeakReference) + reference = (reference as WeakReference).Target; + hardened = true; + } + + void Toggle (bool is_last_ref) + { + if (is_last_ref && reference is GLib.Object) + reference = new WeakReference (reference); + else if (!is_last_ref && reference is WeakReference) { + WeakReference weak = reference as WeakReference; + if (weak.IsAlive) + reference = weak.Target; + } + } + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate void ToggleNotifyHandler (IntPtr data, IntPtr handle, bool is_last_ref); + + static void RefToggled (IntPtr data, IntPtr handle, bool is_last_ref) + { + try { + GCHandle gch = (GCHandle) data; + ToggleRef tref = gch.Target as ToggleRef; + tref.Toggle (is_last_ref); + } catch (Exception e) { + ExceptionManager.RaiseUnhandledException (e, false); + } + } + + static ToggleNotifyHandler toggle_notify_callback; + static ToggleNotifyHandler ToggleNotifyCallback { + get { + if (toggle_notify_callback == null) + toggle_notify_callback = new ToggleNotifyHandler (RefToggled); + return toggle_notify_callback; + } + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_object_add_toggle_ref (IntPtr raw, ToggleNotifyHandler notify_cb, IntPtr data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_object_remove_toggle_ref (IntPtr raw, ToggleNotifyHandler notify_cb, IntPtr data); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_object_ref (IntPtr raw); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_object_unref (IntPtr raw); + + } +} diff --git a/gstreamer-sharp/glib-sharp/TypeConverter.cs b/gstreamer-sharp/glib-sharp/TypeConverter.cs new file mode 100644 index 0000000000..0115d9d1e1 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/TypeConverter.cs @@ -0,0 +1,36 @@ +// GLib.TypeConverter.cs : Convert between fundamental and .NET types +// +// Author: Rachel Hestilow +// +// Copyright (c) 2002 Rachel Hestilow +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + using System; + + public class TypeConverter { + + private TypeConverter () {} + + [Obsolete ("Replaced by explicit (GType) cast")] + public static GType LookupType (System.Type type) + { + return (GType) type; + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/TypeFundamentals.cs b/gstreamer-sharp/glib-sharp/TypeFundamentals.cs new file mode 100644 index 0000000000..db7a6f6c72 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/TypeFundamentals.cs @@ -0,0 +1,47 @@ +// GLib.TypeFundamentals.cs : Standard Types enumeration +// +// Author: Mike Kestner +// +// Copyright (c) 2001 Mike Kestner +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + public enum TypeFundamentals { + TypeInvalid = 0 << 2, + TypeNone = 1 << 2, + TypeInterface = 2 << 2, + TypeChar = 3 << 2, + TypeUChar = 4 << 2, + TypeBoolean = 5 << 2, + TypeInt = 6 << 2, + TypeUInt = 7 << 2, + TypeLong = 8 << 2, + TypeULong = 9 << 2, + TypeInt64 = 10 << 2, + TypeUInt64 = 11 << 2, + TypeEnum = 12 << 2, + TypeFlags = 13 << 2, + TypeFloat = 14 << 2, + TypeDouble = 15 << 2, + TypeString = 16 << 2, + TypePointer = 17 << 2, + TypeBoxed = 18 << 2, + TypeParam = 19 << 2, + TypeObject = 20 << 2, + } +} diff --git a/gstreamer-sharp/glib-sharp/TypeInitializerAttribute.cs b/gstreamer-sharp/glib-sharp/TypeInitializerAttribute.cs new file mode 100644 index 0000000000..400b590586 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/TypeInitializerAttribute.cs @@ -0,0 +1,48 @@ +// TypeInitializerAttribute.cs +// +// Author: Mike Kestner +// +// Copyright (c) 2007 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + + [AttributeUsage (AttributeTargets.Class)] + public sealed class TypeInitializerAttribute : Attribute + { + string method_name; + Type type; + + public TypeInitializerAttribute (Type type, string method_name) + { + this.type = type; + this.method_name = method_name; + } + + public string MethodName { + get { return method_name; } + set { method_name = value; } + } + + public Type Type { + get { return type; } + set { type = value; } + } + } +} diff --git a/gstreamer-sharp/glib-sharp/UnwrappedObject.cs b/gstreamer-sharp/glib-sharp/UnwrappedObject.cs new file mode 100644 index 0000000000..d45ddc23e9 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/UnwrappedObject.cs @@ -0,0 +1,40 @@ +// UnwrappedObject.cs - Class which holds an IntPtr without resolving it: +// +// Author: Rachel Hestilow +// +// Copyright (c) 2002 Rachel Hestilow +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Runtime.InteropServices; + + [Obsolete ("Replaced by direct object-type casts to/from GLib.Value")] + public class UnwrappedObject { + IntPtr obj; + + public UnwrappedObject (IntPtr obj) { + this.obj = obj; + } + + public static explicit operator System.IntPtr (UnwrappedObject obj) { + return obj.obj; + } + } +} + diff --git a/gstreamer-sharp/glib-sharp/Value.cs b/gstreamer-sharp/glib-sharp/Value.cs new file mode 100644 index 0000000000..290d96ae72 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/Value.cs @@ -0,0 +1,675 @@ +// GLib.Value.cs - GLib Value class implementation +// +// Author: Mike Kestner +// +// Copyright (c) 2001 Mike Kestner +// Copyright (c) 2003-2004 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.Reflection; + using System.Runtime.InteropServices; + + [StructLayout (LayoutKind.Sequential)] + public struct Value : IDisposable { + + [StructLayout(LayoutKind.Explicit)] + struct Padding { + [FieldOffset (0)] int v_int; + [FieldOffset (0)] uint v_uint; + [FieldOffset (0)] int v_long; + [FieldOffset (0)] uint v_ulong; + [FieldOffset (0)] long v_int64; + [FieldOffset (0)] ulong v_uint64; + [FieldOffset (0)] float v_float; + [FieldOffset (0)] double v_double; + [FieldOffset (0)] IntPtr v_pointer; + } + + IntPtr type; + Padding pad1; + Padding pad2; + + public static Value Empty; + + public Value (GLib.GType gtype) + { + type = IntPtr.Zero; + pad1 = new Padding (); + pad2 = new Padding (); + g_value_init (ref this, gtype.Val); + } + + public Value (object obj) + { + type = IntPtr.Zero; + pad1 = new Padding (); + pad2 = new Padding (); + + GType gtype = (GType) obj.GetType (); + g_value_init (ref this, gtype.Val); + Val = obj; + } + + public Value (bool val) : this (GType.Boolean) + { + g_value_set_boolean (ref this, val); + } + + public Value (byte val) : this (GType.UChar) + { + g_value_set_uchar (ref this, val); + } + + public Value (sbyte val) : this (GType.Char) + { + g_value_set_char (ref this, val); + } + + public Value (int val) : this (GType.Int) + { + g_value_set_int (ref this, val); + } + + public Value (uint val) : this (GType.UInt) + { + g_value_set_uint (ref this, val); + } + + public Value (ushort val) : this (GType.UInt) + { + g_value_set_uint (ref this, val); + } + + public Value (long val) : this (GType.Int64) + { + g_value_set_int64 (ref this, val); + } + + public Value (ulong val) : this (GType.UInt64) + { + g_value_set_uint64 (ref this, val); + } + + [Obsolete ("Replaced by Value(object) constructor")] + public Value (EnumWrapper wrap, string type_name) + { + type = IntPtr.Zero; + pad1 = new Padding (); + pad2 = new Padding (); + g_value_init (ref this, GType.FromName (type_name).Val); + if (wrap.flags) + g_value_set_flags (ref this, (uint) (int) wrap); + else + g_value_set_enum (ref this, (int) wrap); + } + + public Value (float val) : this (GType.Float) + { + g_value_set_float (ref this, val); + } + + public Value (double val) : this (GType.Double) + { + g_value_set_double (ref this, val); + } + + public Value (string val) : this (GType.String) + { + IntPtr native_val = GLib.Marshaller.StringToPtrGStrdup (val); + g_value_set_string (ref this, native_val); + GLib.Marshaller.Free (native_val); + } + + public Value (ValueArray val) : this (ValueArray.GType) + { + g_value_set_boxed (ref this, val.Handle); + } + + public Value (IntPtr val) : this (GType.Pointer) + { + g_value_set_pointer (ref this, val); + } + + public Value (Opaque val, string type_name) + { + type = IntPtr.Zero; + pad1 = new Padding (); + pad2 = new Padding (); + g_value_init (ref this, GType.FromName (type_name).Val); + g_value_set_boxed (ref this, val.Handle); + } + + public Value (GLib.Object val) : this (val == null ? GType.Object : val.NativeType) + { + g_value_set_object (ref this, val == null ? IntPtr.Zero : val.Handle); + } + + public Value (GLib.GInterfaceAdapter val) : this (val == null ? GType.Object : val.GType) + { + g_value_set_object (ref this, val == null ? IntPtr.Zero : val.Handle); + } + + public Value (GLib.Object obj, string prop_name) + { + type = IntPtr.Zero; + pad1 = new Padding (); + pad2 = new Padding (); + InitForProperty (obj, prop_name); + } + + [Obsolete] + public Value (GLib.Object obj, string prop_name, EnumWrapper wrap) + { + type = IntPtr.Zero; + pad1 = new Padding (); + pad2 = new Padding (); + InitForProperty (obj.NativeType, prop_name); + if (wrap.flags) + g_value_set_flags (ref this, (uint) (int) wrap); + else + g_value_set_enum (ref this, (int) wrap); + } + + [Obsolete] + public Value (IntPtr obj, string prop_name, Opaque val) + { + type = IntPtr.Zero; + pad1 = new Padding (); + pad2 = new Padding (); + InitForProperty (GLib.Object.GetObject (obj), prop_name); + g_value_set_boxed (ref this, val.Handle); + } + + public Value (string[] val) : this (new GLib.GType (g_strv_get_type ())) + { + if (val == null) { + g_value_set_boxed (ref this, IntPtr.Zero); + return; + } + + IntPtr native_array = Marshal.AllocHGlobal ((val.Length + 1) * IntPtr.Size); + for (int i = 0; i < val.Length; i++) + Marshal.WriteIntPtr (native_array, i * IntPtr.Size, GLib.Marshaller.StringToPtrGStrdup (val[i])); + Marshal.WriteIntPtr (native_array, val.Length * IntPtr.Size, IntPtr.Zero); + + g_value_set_boxed (ref this, native_array); + + for (int i = 0; i < val.Length; i++) + GLib.Marshaller.Free (Marshal.ReadIntPtr (native_array, i * IntPtr.Size)); + Marshal.FreeHGlobal (native_array); + } + + + public void Dispose () + { + g_value_unset (ref this); + } + + public void Init (GLib.GType gtype) + { + g_value_init (ref this, gtype.Val); + } + + + public static explicit operator bool (Value val) + { + return g_value_get_boolean (ref val); + } + + public static explicit operator byte (Value val) + { + return g_value_get_uchar (ref val); + } + + public static explicit operator sbyte (Value val) + { + return g_value_get_char (ref val); + } + + public static explicit operator int (Value val) + { + return g_value_get_int (ref val); + } + + public static explicit operator uint (Value val) + { + return g_value_get_uint (ref val); + } + + public static explicit operator ushort (Value val) + { + return (ushort) g_value_get_uint (ref val); + } + + public static explicit operator long (Value val) + { + return g_value_get_int64 (ref val); + } + + public static explicit operator ulong (Value val) + { + return g_value_get_uint64 (ref val); + } + + [Obsolete ("Replaced by Enum cast")] + public static explicit operator EnumWrapper (Value val) + { + if (val.HoldsFlags) + return new EnumWrapper ((int)g_value_get_flags (ref val), true); + else + return new EnumWrapper (g_value_get_enum (ref val), false); + } + + public static explicit operator Enum (Value val) + { + if (val.HoldsFlags) + return (Enum)Enum.ToObject (GType.LookupType (val.type), g_value_get_flags (ref val)); + else + return (Enum)Enum.ToObject (GType.LookupType (val.type), g_value_get_enum (ref val)); + } + + public static explicit operator float (Value val) + { + return g_value_get_float (ref val); + } + + public static explicit operator double (Value val) + { + return g_value_get_double (ref val); + } + + public static explicit operator string (Value val) + { + IntPtr str = g_value_get_string (ref val); + return str == IntPtr.Zero ? null : GLib.Marshaller.Utf8PtrToString (str); + } + + public static explicit operator ValueArray (Value val) + { + return new ValueArray (g_value_get_boxed (ref val)); + } + + public static explicit operator IntPtr (Value val) + { + return g_value_get_pointer (ref val); + } + + public static explicit operator GLib.Opaque (Value val) + { + return GLib.Opaque.GetOpaque (g_value_get_boxed (ref val), (Type) new GType (val.type), false); + } + + public static explicit operator GLib.Boxed (Value val) + { + return new GLib.Boxed (g_value_get_boxed (ref val)); + } + + public static explicit operator GLib.Object (Value val) + { + return GLib.Object.GetObject (g_value_get_object (ref val), false); + } + + [Obsolete ("Replaced by GLib.Object cast")] + public static explicit operator GLib.UnwrappedObject (Value val) + { + return new UnwrappedObject (g_value_get_object (ref val)); + } + + public static explicit operator string[] (Value val) + { + IntPtr native_array = g_value_get_boxed (ref val); + if (native_array == IntPtr.Zero) + return null; + + int count = 0; + while (Marshal.ReadIntPtr (native_array, count * IntPtr.Size) != IntPtr.Zero) + count++; + string[] strings = new string[count]; + for (int i = 0; i < count; i++) + strings[i] = GLib.Marshaller.Utf8PtrToString (Marshal.ReadIntPtr (native_array, i * IntPtr.Size)); + return strings; + } + + object ToRegisteredType () { + Type t = GLib.GType.LookupType (type); + ConstructorInfo ci = null; + + try { + while (ci == null && t != null) { + if (!t.IsAbstract) + ci = t.GetConstructor (new Type[] { typeof (GLib.Value) }); + if (ci == null) + t = t.BaseType; + } + } catch (Exception) { + ci = null; + } + + if (ci == null) + throw new Exception ("Unknown type " + new GType (type).ToString ()); + + return ci.Invoke (new object[] {this}); + } + + void FromRegisteredType (object val) { + Type t = GLib.GType.LookupType (type); + MethodInfo mi = null; + + try { + while (mi == null && t != null) { + mi = t.GetMethod ("SetGValue", new Type[] { Type.GetType ("GLib.Value&") }); + if (mi != null && (mi.IsAbstract || mi.ReturnType != typeof (void))) + mi = null; + if (mi == null) + t = t.BaseType; + } + } catch (Exception) { + mi = null; + } + + if (mi == null) + throw new Exception ("Unknown type " + new GType (type).ToString ()); + + object[] parameters = new object[] { this }; + mi.Invoke (val, parameters); + this = (GLib.Value) parameters[0]; + } + + object ToEnum () + { + Type t = GType.LookupType (type); + + if (t == null) { + if (HoldsFlags) + return g_value_get_flags (ref this); + else + return g_value_get_enum (ref this); + } else { + return (Enum) this; + } + } + + object ToBoxed () + { + IntPtr boxed_ptr = g_value_get_boxed (ref this); + Type t = GType.LookupType (type); + if (t == null) + throw new Exception ("Unknown type " + new GType (type).ToString ()); + else if (t.IsSubclassOf (typeof (GLib.Opaque))) + return (GLib.Opaque) this; + + MethodInfo mi = t.GetMethod ("New", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy); + if (mi == null) + return Marshal.PtrToStructure (boxed_ptr, t); + else + return mi.Invoke (null, new object[] {boxed_ptr}); + } + + public object Val + { + get { + if (type == GType.Boolean.Val) + return (bool) this; + else if (type == GType.UChar.Val) + return (byte) this; + else if (type == GType.Char.Val) + return (sbyte) this; + else if (type == GType.Int.Val) + return (int) this; + else if (type == GType.UInt.Val) + return (uint) this; + else if (type == GType.Int64.Val) + return (long) this; + else if (type == GType.UInt64.Val) + return (ulong) this; + else if (GType.Is (type, GType.Enum) || + GType.Is (type, GType.Flags)) + return ToEnum (); + else if (type == GType.Float.Val) + return (float) this; + else if (type == GType.Double.Val) + return (double) this; + else if (type == GType.String.Val) + return (string) this; + else if (type == GType.Pointer.Val) + return (IntPtr) this; + else if (type == GType.Param.Val) + return g_value_get_param (ref this); + else if (type == ValueArray.GType.Val) + return new ValueArray (g_value_get_boxed (ref this)); + else if (type == ManagedValue.GType.Val) + return ManagedValue.ObjectForWrapper (g_value_get_boxed (ref this)); + else if (GType.Is (type, GType.Object)) + return (GLib.Object) this; + else if (GType.Is (type, GType.Boxed)) + return ToBoxed (); + else if (GType.LookupType (type) != null) + return ToRegisteredType (); + else if (type == IntPtr.Zero) + return null; + else + throw new Exception ("Unknown type " + new GType (type).ToString ()); + } + set { + if (type == GType.Boolean.Val) + g_value_set_boolean (ref this, (bool) value); + else if (type == GType.UChar.Val) + g_value_set_uchar (ref this, (byte) value); + else if (type == GType.Char.Val) + g_value_set_char (ref this, (sbyte) value); + else if (type == GType.Int.Val) + g_value_set_int (ref this, (int) value); + else if (type == GType.UInt.Val) + g_value_set_uint (ref this, (uint) value); + else if (type == GType.Int64.Val) + g_value_set_int64 (ref this, (long) value); + else if (type == GType.UInt64.Val) + g_value_set_uint64 (ref this, (ulong) value); + else if (GType.Is (type, GType.Enum)) + g_value_set_enum (ref this, (int)value); + else if (GType.Is (type, GType.Flags)) + g_value_set_flags (ref this, (uint)(int)value); + else if (type == GType.Float.Val) + g_value_set_float (ref this, (float) value); + else if (type == GType.Double.Val) + g_value_set_double (ref this, (double) value); + else if (type == GType.String.Val) { + IntPtr native = GLib.Marshaller.StringToPtrGStrdup ((string)value); + g_value_set_string (ref this, native); + GLib.Marshaller.Free (native); + } else if (type == GType.Pointer.Val) { + if (value.GetType () == typeof (IntPtr)) { + g_value_set_pointer (ref this, (IntPtr) value); + return; + } else if (value is IWrapper) { + g_value_set_pointer (ref this, ((IWrapper)value).Handle); + return; + } + IntPtr buf = Marshal.AllocHGlobal (Marshal.SizeOf (value.GetType())); + Marshal.StructureToPtr (value, buf, false); + g_value_set_pointer (ref this, buf); + } else if (type == GType.Param.Val) { + g_value_set_param (ref this, (IntPtr) value); + } else if (type == ValueArray.GType.Val) { + g_value_set_boxed (ref this, ((ValueArray) value).Handle); + } else if (type == ManagedValue.GType.Val) { + IntPtr wrapper = ManagedValue.WrapObject (value); + g_value_set_boxed (ref this, wrapper); + ManagedValue.ReleaseWrapper (wrapper); + } else if (GType.Is (type, GType.Object)) + if(value is GLib.Object) + g_value_set_object (ref this, (value as GLib.Object).Handle); + else + g_value_set_object (ref this, (value as GLib.GInterfaceAdapter).Handle); + else if (GType.Is (type, GType.Boxed)) { + if (value is IWrapper) { + g_value_set_boxed (ref this, ((IWrapper)value).Handle); + return; + } + IntPtr buf = Marshaller.StructureToPtrAlloc (value); + g_value_set_boxed (ref this, buf); + Marshal.FreeHGlobal (buf); + } else if (GLib.GType.LookupType (type) != null) { + FromRegisteredType (value); + } else + throw new Exception ("Unknown type " + new GType (type).ToString ()); + } + } + + internal void Update (object val) + { + if (GType.Is (type, GType.Boxed) && !(val is IWrapper)) + Marshal.StructureToPtr (val, g_value_get_boxed (ref this), false); + } + + bool HoldsFlags { + get { return g_type_check_value_holds (ref this, GType.Flags.Val); } + } + + void InitForProperty (Object obj, string name) + { + GType gtype = obj.NativeType; + InitForProperty (gtype, name); + } + + void InitForProperty (GType gtype, string name) + { + IntPtr p_name = Marshaller.StringToPtrGStrdup (name); + IntPtr spec_ptr = g_object_class_find_property (gtype.ClassPtr, p_name); + Marshaller.Free (p_name); + + if (spec_ptr == IntPtr.Zero) + throw new Exception (String.Format ("No property with name '{0}' in type '{1}'", name, gtype.ToString())); + + ParamSpec spec = new ParamSpec (spec_ptr); + g_value_init (ref this, spec.ValueType.Val); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_object_class_find_property (IntPtr klass, IntPtr name); + + [DllImport("libgobject-2.0-0.dll")] + static extern bool g_type_check_value_holds (ref Value val, IntPtr gtype); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_init (ref GLib.Value val, IntPtr gtype); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_unset (ref GLib.Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_boolean (ref Value val, bool data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_uchar (ref Value val, byte data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_char (ref Value val, sbyte data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_boxed (ref Value val, IntPtr data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_double (ref Value val, double data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_float (ref Value val, float data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_int (ref Value val, int data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_int64 (ref Value val, long data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_uint64 (ref Value val, ulong data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_object (ref Value val, IntPtr data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_param (ref Value val, IntPtr data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_pointer (ref Value val, IntPtr data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_string (ref Value val, IntPtr data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_uint (ref Value val, uint data); + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_enum (ref Value val, int data); + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_set_flags (ref Value val, uint data); + + [DllImport("libgobject-2.0-0.dll")] + static extern bool g_value_get_boolean (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern byte g_value_get_uchar (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern sbyte g_value_get_char (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_value_get_boxed (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern double g_value_get_double (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern float g_value_get_float (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern int g_value_get_int (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern long g_value_get_int64 (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern ulong g_value_get_uint64 (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_value_get_object (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_value_get_param (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_value_get_pointer (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_value_get_string (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern uint g_value_get_uint (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern int g_value_get_enum (ref Value val); + [DllImport("libgobject-2.0-0.dll")] + static extern uint g_value_get_flags (ref Value val); + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_strv_get_type (); + } +} diff --git a/gstreamer-sharp/glib-sharp/ValueArray.cs b/gstreamer-sharp/glib-sharp/ValueArray.cs new file mode 100644 index 0000000000..3573970617 --- /dev/null +++ b/gstreamer-sharp/glib-sharp/ValueArray.cs @@ -0,0 +1,247 @@ +// ValueArray.cs - ValueArray wrapper implementation +// +// Authors: Mike Kestner +// +// Copyright (c) 2003 Novell, Inc. +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of version 2 of the Lesser GNU General +// Public License as published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program; if not, write to the +// Free Software Foundation, Inc., 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + + +namespace GLib { + + using System; + using System.Collections; + using System.Runtime.InteropServices; + + public class ValueArray : IDisposable, ICollection, ICloneable, IWrapper { + + private IntPtr handle = IntPtr.Zero; + + static private ArrayList PendingFrees = new ArrayList (); + static private bool idle_queued = false; + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_value_array_new (uint n_preallocs); + + public ValueArray (uint n_preallocs) + { + handle = g_value_array_new (n_preallocs); + } + + public ValueArray (IntPtr raw) + { + handle = raw; + } + + ~ValueArray () + { + Dispose (false); + } + + // IDisposable + public void Dispose () + { + Dispose (true); + GC.SuppressFinalize (this); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_array_free (IntPtr raw); + + void Dispose (bool disposing) + { + if (Handle == IntPtr.Zero) + return; + + lock (PendingFrees) { + PendingFrees.Add (handle); + + if (! idle_queued) { + Timeout.Add (50, new TimeoutHandler (PerformFrees)); + idle_queued = true; + } + } + + handle = IntPtr.Zero; + } + + static bool PerformFrees () + { + IntPtr[] handles; + + lock (PendingFrees) { + idle_queued = false; + + handles = new IntPtr [PendingFrees.Count]; + PendingFrees.CopyTo (handles, 0); + PendingFrees.Clear (); + } + + foreach (IntPtr h in handles) + g_value_array_free (h); + + return false; + } + + public IntPtr Handle { + get { + return handle; + } + } + + struct NativeStruct { + public uint n_values; + public IntPtr values; + public uint n_prealloced; + } + + NativeStruct Native { + get { return (NativeStruct) Marshal.PtrToStructure (Handle, typeof(NativeStruct)); } + } + + public IntPtr ArrayPtr { + get { return Native.values; } + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_array_append (IntPtr raw, ref GLib.Value val); + + public void Append (GLib.Value val) + { + g_value_array_append (Handle, ref val); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_array_insert (IntPtr raw, uint idx, ref GLib.Value val); + + public void Insert (uint idx, GLib.Value val) + { + g_value_array_insert (Handle, idx, ref val); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_array_prepend (IntPtr raw, ref GLib.Value val); + + public void Prepend (GLib.Value val) + { + g_value_array_prepend (Handle, ref val); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern void g_value_array_remove (IntPtr raw, uint idx); + + public void Remove (uint idx) + { + g_value_array_remove (Handle, idx); + } + + // ICollection + public int Count { + get { return (int) Native.n_values; } + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_value_array_get_nth (IntPtr raw, uint idx); + + public object this [int index] { + get { + IntPtr raw_val = g_value_array_get_nth (Handle, (uint) index); + return Marshal.PtrToStructure (raw_val, typeof (GLib.Value)); + } + } + + // Synchronization could be tricky here. Hmm. + public bool IsSynchronized { + get { return false; } + } + + public object SyncRoot { + get { return null; } + } + + public void CopyTo (Array array, int index) + { + if (array == null) + throw new ArgumentNullException ("Array can't be null."); + + if (index < 0) + throw new ArgumentOutOfRangeException ("Index must be greater than 0."); + + if (index + Count < array.Length) + throw new ArgumentException ("Array not large enough to copy into starting at index."); + + for (int i = 0; i < Count; i++) + ((IList) array) [index + i] = this [i]; + } + + private class ListEnumerator : IEnumerator + { + private int current = -1; + private ValueArray vals; + + public ListEnumerator (ValueArray vals) + { + this.vals = vals; + } + + public object Current { + get { + if (current == -1) + return null; + return vals [current]; + } + } + + public bool MoveNext () + { + if (++current >= vals.Count) { + current = -1; + return false; + } + + return true; + } + + public void Reset () + { + current = -1; + } + } + + // IEnumerable + public IEnumerator GetEnumerator () + { + return new ListEnumerator (this); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_value_array_copy (IntPtr raw); + + // ICloneable + public object Clone () + { + return new ValueArray (g_value_array_copy (Handle)); + } + + [DllImport ("libgobject-2.0-0.dll")] + static extern IntPtr g_value_array_get_type (); + + public static GLib.GType GType { + get { + return new GLib.GType (g_value_array_get_type ()); + } + } + } +} diff --git a/gstreamer-sharp/glib-sharp/WeakObject.cs b/gstreamer-sharp/glib-sharp/WeakObject.cs new file mode 100644 index 0000000000..e69de29bb2