89cfd16c10
The API contract between GObject-Introspection and bindings is that functions returning transfer-none floating references pass a reference to the bindings that should be taken ownership of by sinking it. Not doing so is wrong and will lead to memory leaks or double frees. Previously we would not distinguish this case and simply increment the reference count. In addition we would then sink the floating reference when the Object.Raw field is set later for InitiallyUnowned subclasses. Remove that last part and instead check directly in Object.Raw.set if we get a floating reference and if so simply sink it here and take ownership of it. The general assumption of Object.Raw.set is that it gets passed a reference that it should take ownership of. So in summary: 1) GetObject() would only increase the reference count of unowned, non-floating references so that we own it. For unowned, floating references it assumes ownership of the reference. 2) Raw.set assumes ownership of the reference passed to it and if it happens to be a floating reference then it will first sink it. Also warn if we get a floating, owned reference passed to GetObject() as that case is not allowed by GObject-Introspection and would cause the reference to be leaked. This fixes a memory leak with functions returning unowned, floating references and with functions returning owned, non-floating references of InitiallyUnowned subclasses. And at the same time keeps constructors for InitiallyUnowned subclasses working correctly without leaks. See https://gitlab.freedesktop.org/gstreamer/gstreamer-sharp/issues/31
1101 lines
36 KiB
C#
1101 lines
36 KiB
C#
// Object.cs - GObject class wrapper implementation
|
|
//
|
|
// Authors: Mike Kestner <mkestner@speakeasy.net>
|
|
// Andres G. Aragoneses <knocte@gmail.com>
|
|
//
|
|
// Copyright (c) 2001-2003 Mike Kestner
|
|
// Copyright (c) 2004-2005 Novell, Inc.
|
|
// Copyright (c) 2013 Andres G. Aragoneses
|
|
//
|
|
// 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.Generic;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
|
|
public class Object : IWrapper, IDisposable {
|
|
|
|
IntPtr handle;
|
|
ToggleRef tref;
|
|
bool disposed = false;
|
|
static uint idx = 1;
|
|
static Dictionary<IntPtr, ToggleRef> Objects = new Dictionary<IntPtr, ToggleRef>();
|
|
static Dictionary<IntPtr, Dictionary<IntPtr, GLib.Value>> PropertiesToSet = new Dictionary<IntPtr, Dictionary<IntPtr, GLib.Value>>();
|
|
|
|
~Object ()
|
|
{
|
|
if (WarnOnFinalize)
|
|
Console.Error.WriteLine ("Unexpected finalization of " + GetType() + " instance. Consider calling Dispose.");
|
|
|
|
Dispose (false);
|
|
}
|
|
|
|
public void Dispose ()
|
|
{
|
|
if (disposed)
|
|
return;
|
|
|
|
Dispose (true);
|
|
disposed = true;
|
|
GC.SuppressFinalize (this);
|
|
}
|
|
|
|
protected virtual void Dispose (bool disposing)
|
|
{
|
|
ToggleRef tref;
|
|
lock (Objects) {
|
|
if (Objects.TryGetValue (Handle, out tref)) {
|
|
Objects.Remove (Handle);
|
|
}
|
|
}
|
|
|
|
handle = IntPtr.Zero;
|
|
if (tref == null)
|
|
return;
|
|
|
|
if (disposing)
|
|
tref.Dispose ();
|
|
else
|
|
tref.QueueUnref ();
|
|
|
|
// Free all internal signals, else the garbage collector is not
|
|
// able to free the object.
|
|
if (signals != null)
|
|
{
|
|
foreach (var sig in signals.Keys)
|
|
signals[sig].Free ();
|
|
}
|
|
|
|
signals = null;
|
|
}
|
|
|
|
public static bool WarnOnFinalize { get; set; }
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate IntPtr d_g_object_ref(IntPtr raw);
|
|
static d_g_object_ref g_object_ref = FuncLoader.LoadFunction<d_g_object_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_ref"));
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate void d_g_object_unref(IntPtr raw);
|
|
static d_g_object_unref g_object_unref = FuncLoader.LoadFunction<d_g_object_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_unref"));
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate bool d_g_object_is_floating(IntPtr raw);
|
|
static d_g_object_is_floating g_object_is_floating = FuncLoader.LoadFunction<d_g_object_is_floating>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_is_floating"));
|
|
|
|
public static Object TryGetObject (IntPtr o)
|
|
{
|
|
if (o == IntPtr.Zero)
|
|
return null;
|
|
|
|
ToggleRef toggle_ref;
|
|
lock (Objects) {
|
|
if (!Objects.TryGetValue (o, out toggle_ref)) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (toggle_ref != null) {
|
|
return toggle_ref.Target;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static Object GetObject(IntPtr o, bool owned_ref)
|
|
{
|
|
if (o == IntPtr.Zero)
|
|
return null;
|
|
|
|
Object obj = null;
|
|
|
|
ToggleRef toggle_ref;
|
|
lock (Objects) {
|
|
if (Objects.TryGetValue (o, out toggle_ref)) {
|
|
if (toggle_ref != null)
|
|
obj = toggle_ref.Target;
|
|
}
|
|
}
|
|
|
|
if (obj != null && obj.Handle == o) {
|
|
if (owned_ref)
|
|
g_object_unref (obj.Handle);
|
|
return obj;
|
|
}
|
|
|
|
bool unexpected_owned_floating = false;
|
|
// If we don't get an owned reference here then we need to increase the
|
|
// reference count as CreateObject() always takes an owned reference.
|
|
// If we get a floating reference passed, however, then we assume that
|
|
// we actually own it and have to sink the floating reference, which
|
|
// will happen in the setter for Raw later.
|
|
if (!owned_ref && !g_object_is_floating(o))
|
|
g_object_ref (o);
|
|
else if (owned_ref && g_object_is_floating(o))
|
|
unexpected_owned_floating = true;
|
|
|
|
obj = GLib.ObjectManager.CreateObject(o);
|
|
if (obj == null) {
|
|
g_object_unref (o);
|
|
return null;
|
|
}
|
|
|
|
if (unexpected_owned_floating)
|
|
Console.Error.WriteLine ("Unexpected owned floating reference of " + obj.GetType() + " instance. This will be leaked");
|
|
|
|
return obj;
|
|
}
|
|
|
|
public static Object GetObject(IntPtr o)
|
|
{
|
|
return GetObject (o, false);
|
|
}
|
|
|
|
// Key: The Type for the set of properties
|
|
// Value->SubKey: The pointer to the ParamSpec of the property
|
|
// Value->SubValue: The corresponding PropertyInfo object
|
|
static Dictionary<Type, Dictionary<IntPtr, PropertyInfo>> properties;
|
|
static Dictionary<Type, Dictionary<IntPtr, PropertyInfo>> Properties {
|
|
get {
|
|
if (properties == null)
|
|
properties = new Dictionary<Type, Dictionary<IntPtr, PropertyInfo>> ();
|
|
return properties;
|
|
}
|
|
}
|
|
|
|
static Dictionary<IntPtr, Dictionary<Type, PropertyInfo>> interface_properties;
|
|
static Dictionary<IntPtr, Dictionary<Type, PropertyInfo>> IProperties {
|
|
get {
|
|
if (interface_properties == null)
|
|
interface_properties = new Dictionary<IntPtr, Dictionary<Type, PropertyInfo>> ();
|
|
return interface_properties;
|
|
}
|
|
}
|
|
|
|
struct GTypeClass {
|
|
public IntPtr gtype;
|
|
}
|
|
|
|
struct GObjectClass {
|
|
public GTypeClass type_class;
|
|
public IntPtr construct_props;
|
|
public ConstructorDelegate constructor_cb;
|
|
public SetPropertyDelegate set_prop_cb;
|
|
public GetPropertyDelegate get_prop_cb;
|
|
public IntPtr dispose;
|
|
public IntPtr finalize;
|
|
public IntPtr dispatch_properties_changed;
|
|
public IntPtr notify;
|
|
public IntPtr constructed;
|
|
public IntPtr dummy1;
|
|
public IntPtr dummy2;
|
|
public IntPtr dummy3;
|
|
public IntPtr dummy4;
|
|
public IntPtr dummy5;
|
|
public IntPtr dummy6;
|
|
public IntPtr dummy7;
|
|
}
|
|
|
|
internal class ClassInitializer {
|
|
|
|
internal Type Type { get; private set; }
|
|
internal bool HandlersOverriden { get; private set; }
|
|
internal GType.ClassInitDelegate ClassInitManagedDelegate { get; private set; }
|
|
|
|
uint idx = 1;
|
|
bool is_first_subclass;
|
|
private GType gtype;
|
|
private List<GInterfaceAdapter> adapters = new List<GInterfaceAdapter> ();
|
|
|
|
internal ClassInitializer (Type type)
|
|
{
|
|
ClassInitManagedDelegate = this.ClassInit;
|
|
Type = type;
|
|
gtype = GType.RegisterGObjectType (this);
|
|
is_first_subclass = gtype.GetBaseType () == gtype.GetThresholdType ();
|
|
}
|
|
|
|
internal GType Init ()
|
|
{
|
|
AddGInterfaces ();
|
|
gtype.EnsureClass (); //calls class_init
|
|
|
|
ConnectDefaultHandlers ();
|
|
InvokeTypeInitializers ();
|
|
AddInterfaceProperties ();
|
|
return gtype;
|
|
}
|
|
|
|
private void AddGInterfaces ()
|
|
{
|
|
foreach (Type iface in Type.GetInterfaces ()) {
|
|
if (!iface.IsDefined (typeof (GInterfaceAttribute), true))
|
|
continue;
|
|
|
|
GInterfaceAttribute attr = iface.GetCustomAttributes (typeof (GInterfaceAttribute), false) [0] as GInterfaceAttribute;
|
|
GInterfaceAdapter adapter = Activator.CreateInstance (attr.AdapterType, null) as GInterfaceAdapter;
|
|
|
|
if (!iface.IsAssignableFrom (Type.BaseType)) {
|
|
GInterfaceInfo info = adapter.Info;
|
|
info.Data = gtype.Val;
|
|
g_type_add_interface_static (gtype.Val, adapter.GInterfaceGType.Val, ref info);
|
|
adapters.Add (adapter);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ClassInit (IntPtr gobject_class_handle)
|
|
{
|
|
bool override_ctor = is_first_subclass;
|
|
|
|
bool override_props = is_first_subclass || adapters.Count > 0;
|
|
|
|
OverrideHandlers (gobject_class_handle, override_ctor, override_props);
|
|
|
|
foreach (GInterfaceAdapter adapter in adapters) {
|
|
InitializeProperties (adapter, gobject_class_handle);
|
|
}
|
|
|
|
AddProperties (gobject_class_handle);
|
|
}
|
|
|
|
private void InitializeProperties (GInterfaceAdapter adapter, IntPtr gobject_class_handle)
|
|
{
|
|
foreach (PropertyInfo pinfo in adapter.GetType ().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 ("Property {0} of type {1} cannot be overriden because its GLib.PropertyAttribute is expected to have one or more indexed parameters",
|
|
pinfo.Name, adapter.GetType ().FullName));
|
|
|
|
PropertyAttribute property_attr = attr as PropertyAttribute;
|
|
if (property_attr != null) {
|
|
OverrideProperty (gobject_class_handle, property_attr.Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OverrideProperty (IntPtr declaring_class, string name)
|
|
{
|
|
Object.OverrideProperty (declaring_class, idx++, name);
|
|
idx++;
|
|
}
|
|
|
|
private void OverrideHandlers (bool ctor, bool properties)
|
|
{
|
|
OverrideHandlers (gtype.GetClassPtr (), ctor, properties);
|
|
}
|
|
|
|
private void OverrideHandlers (IntPtr gobject_class_handle, bool ctor, bool properties)
|
|
{
|
|
if (HandlersOverriden || (ctor == false && properties == false))
|
|
return;
|
|
|
|
GObjectClass gobject_class = (GObjectClass)Marshal.PtrToStructure (gobject_class_handle, typeof(GObjectClass));
|
|
if (ctor) {
|
|
gobject_class.constructor_cb = GLib.Object.ConstructorHandler;
|
|
}
|
|
if (properties) {
|
|
gobject_class.get_prop_cb = GLib.Object.GetPropertyHandler;
|
|
gobject_class.set_prop_cb = GLib.Object.SetPropertyHandler;
|
|
}
|
|
Marshal.StructureToPtr (gobject_class, gobject_class_handle, false);
|
|
HandlersOverriden = true;
|
|
}
|
|
|
|
void AddProperties (IntPtr gobject_class_handle)
|
|
{
|
|
if (is_first_subclass) {
|
|
ParamSpec pspec = new ParamSpec ("gtk-sharp-managed-instance", "", "", GType.Pointer, ParamFlags.Writable | ParamFlags.ConstructOnly);
|
|
g_object_class_install_property (gobject_class_handle, idx, pspec.Handle);
|
|
idx++;
|
|
}
|
|
|
|
foreach (PropertyInfo pinfo in Type.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, Type.FullName));
|
|
|
|
OverrideHandlers (false, true);
|
|
|
|
PropertyAttribute property_attr = attr as PropertyAttribute;
|
|
try {
|
|
IntPtr param_spec = RegisterProperty (gtype, property_attr.Name, property_attr.Nickname, property_attr.Blurb, idx, (GType) pinfo.PropertyType, pinfo.CanRead, pinfo.CanWrite);
|
|
Type type = (Type)gtype;
|
|
Dictionary<IntPtr, PropertyInfo> gtype_properties;
|
|
if (!Properties.TryGetValue (type, out gtype_properties)) {
|
|
gtype_properties = new Dictionary<IntPtr, PropertyInfo> ();
|
|
Properties [type] = gtype_properties;
|
|
}
|
|
gtype_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, Type.FullName));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AddInterfaceProperties ()
|
|
{
|
|
foreach (Type iface in Type.GetInterfaces ()) {
|
|
if (!iface.IsDefined (typeof (GInterfaceAttribute), true))
|
|
continue;
|
|
|
|
GInterfaceAttribute attr = iface.GetCustomAttributes (typeof (GInterfaceAttribute), false) [0] as GInterfaceAttribute;
|
|
GInterfaceAdapter adapter = Activator.CreateInstance (attr.AdapterType, null) as GInterfaceAdapter;
|
|
|
|
foreach (PropertyInfo p in iface.GetProperties ()) {
|
|
PropertyAttribute[] attrs = p.GetCustomAttributes (typeof (PropertyAttribute), true) as PropertyAttribute [];
|
|
if (attrs.Length == 0)
|
|
continue;
|
|
PropertyAttribute property_attr = attrs [0];
|
|
PropertyInfo declared_prop = Type.GetProperty (p.Name, BindingFlags.Public | BindingFlags.Instance);
|
|
if (declared_prop == null)
|
|
continue;
|
|
IntPtr param_spec = FindInterfaceProperty (adapter.GInterfaceGType, property_attr.Name);
|
|
|
|
Dictionary<IntPtr, PropertyInfo> props;
|
|
if (!Properties.TryGetValue (Type, out props)) {
|
|
props = new Dictionary<IntPtr, PropertyInfo> ();
|
|
Properties [Type] = props;
|
|
}
|
|
props [param_spec] = declared_prop;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ConnectDefaultHandlers ()
|
|
{
|
|
foreach (MethodInfo minfo in Type.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;
|
|
}
|
|
}
|
|
}
|
|
|
|
void InvokeTypeInitializers ()
|
|
{
|
|
object[] parms = {gtype, Type};
|
|
|
|
BindingFlags flags = BindingFlags.Static | BindingFlags.NonPublic;
|
|
|
|
foreach (TypeInitializerAttribute tia in Type.GetCustomAttributes (typeof (TypeInitializerAttribute), true)) {
|
|
MethodInfo m = tia.Type.GetMethod (tia.MethodName, flags);
|
|
if (m != null)
|
|
m.Invoke (null, parms);
|
|
}
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate IntPtr ConstructorDelegate (IntPtr gtype, uint n_construct_properties, IntPtr construct_properties);
|
|
|
|
static ConstructorDelegate constructor_handler;
|
|
|
|
static ConstructorDelegate ConstructorHandler {
|
|
get {
|
|
if (constructor_handler == null)
|
|
constructor_handler = new ConstructorDelegate (ConstructorCallback);
|
|
return constructor_handler;
|
|
}
|
|
}
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate IntPtr d_g_param_spec_get_name(IntPtr pspec);
|
|
static d_g_param_spec_get_name g_param_spec_get_name = FuncLoader.LoadFunction<d_g_param_spec_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_get_name"));
|
|
|
|
static IntPtr ConstructorCallback (IntPtr gtypeval, uint n_construct_properties, IntPtr construct_properties)
|
|
{
|
|
GType gtype = new GLib.GType (gtypeval);
|
|
GObjectClass threshold_class = (GObjectClass) Marshal.PtrToStructure (gtype.GetThresholdType ().GetClassPtr (), typeof (GObjectClass));
|
|
IntPtr raw = threshold_class.constructor_cb (gtypeval, n_construct_properties, construct_properties);
|
|
Dictionary<IntPtr, GLib.Value> deferred;
|
|
|
|
GLib.Object obj = null;
|
|
for (int i = 0; i < n_construct_properties; i++) {
|
|
IntPtr p = new IntPtr (construct_properties.ToInt64 () + i * 2 * IntPtr.Size);
|
|
|
|
string prop_name = Marshaller.Utf8PtrToString (g_param_spec_get_name (Marshal.ReadIntPtr (p)));
|
|
if (prop_name != "gtk-sharp-managed-instance")
|
|
continue;
|
|
|
|
Value val = (Value) Marshal.PtrToStructure (Marshal.ReadIntPtr (p, IntPtr.Size), typeof (Value));
|
|
if ((IntPtr) val.Val != IntPtr.Zero) {
|
|
GCHandle gch = (GCHandle) (IntPtr) val.Val;
|
|
obj = (GLib.Object) gch.Target;
|
|
obj.Raw = raw;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (obj == null)
|
|
obj = GetObject (raw, false);
|
|
|
|
if(PropertiesToSet.TryGetValue(raw, out deferred)) {
|
|
foreach(var item in deferred) {
|
|
SetDeferredProperty(obj, item.Value, item.Key);
|
|
}
|
|
PropertiesToSet.Remove(raw);
|
|
}
|
|
return raw;
|
|
}
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate void d_g_object_class_override_property(IntPtr klass, uint prop_id, IntPtr name);
|
|
static d_g_object_class_override_property g_object_class_override_property = FuncLoader.LoadFunction<d_g_object_class_override_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_class_override_property"));
|
|
|
|
public static void OverrideProperty (IntPtr oclass, uint property_id, string name)
|
|
{
|
|
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
|
|
g_object_class_override_property (oclass, property_id, native_name);
|
|
GLib.Marshaller.Free (native_name);
|
|
}
|
|
|
|
[Obsolete ("Use OverrideProperty(oclass,property_id,name)")]
|
|
public static void OverrideProperty (IntPtr declaring_class, string name)
|
|
{
|
|
OverrideProperty (declaring_class, idx, name);
|
|
idx++;
|
|
}
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate IntPtr d_g_object_class_find_property(IntPtr klass, IntPtr name);
|
|
static d_g_object_class_find_property g_object_class_find_property = FuncLoader.LoadFunction<d_g_object_class_find_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_class_find_property"));
|
|
|
|
static IntPtr FindClassProperty (GLib.Object o, string name)
|
|
{
|
|
IntPtr gobjectclass = Marshal.ReadIntPtr (o.Handle);
|
|
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
|
|
try
|
|
{
|
|
return g_object_class_find_property (gobjectclass, native_name);
|
|
}
|
|
finally
|
|
{
|
|
GLib.Marshaller.Free (native_name);
|
|
}
|
|
}
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate IntPtr d_g_object_interface_find_property(IntPtr klass, IntPtr name);
|
|
static d_g_object_interface_find_property g_object_interface_find_property = FuncLoader.LoadFunction<d_g_object_interface_find_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_interface_find_property"));
|
|
|
|
static IntPtr FindInterfaceProperty (GType type, string name)
|
|
{
|
|
IntPtr g_iface = type.GetDefaultInterfacePtr ();
|
|
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
|
|
try
|
|
{
|
|
return g_object_interface_find_property (g_iface, native_name);
|
|
}
|
|
finally
|
|
{
|
|
GLib.Marshaller.Free (native_name);
|
|
}
|
|
}
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate void d_g_object_class_install_property(IntPtr klass, uint prop_id, IntPtr param_spec);
|
|
static d_g_object_class_install_property g_object_class_install_property = FuncLoader.LoadFunction<d_g_object_class_install_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_class_install_property"));
|
|
|
|
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.GetClassPtr ();
|
|
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;
|
|
}
|
|
|
|
[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)
|
|
{
|
|
GLib.Object obj = GLib.Object.GetObject (handle, false);
|
|
var type = (Type)obj.LookupGType ();
|
|
|
|
Dictionary<IntPtr, PropertyInfo> props;
|
|
if (!Properties.TryGetValue (type, out props))
|
|
return;
|
|
|
|
PropertyInfo prop;
|
|
if (!props.TryGetValue (param_spec, out prop))
|
|
return;
|
|
|
|
value.Val = prop.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)
|
|
{
|
|
// There are multiple issues in this place.
|
|
// We cannot construct an object here as it can be in construction
|
|
// from ConstructorCallback thus managed object already created.
|
|
//
|
|
// We cannot use the "gtk-sharp-managed-instance" property as when
|
|
// constructed by Gtk.Builder it is set to null.
|
|
//
|
|
// We defer setting the properties to later time when
|
|
// we have unmanaged and managed objects paired.
|
|
GLib.Object obj = TryGetObject(handle);
|
|
if(obj != null) {
|
|
SetDeferredProperty(obj, value, param_spec);
|
|
return;
|
|
}
|
|
Dictionary<IntPtr, GLib.Value> deferred;
|
|
if(!PropertiesToSet.TryGetValue(handle, out deferred)) {
|
|
deferred = new Dictionary<IntPtr, GLib.Value>();
|
|
PropertiesToSet.Add(handle, deferred);
|
|
}
|
|
deferred[param_spec] = value;
|
|
}
|
|
|
|
static void SetDeferredProperty(GLib.Object obj, GLib.Value value, IntPtr param_spec)
|
|
{
|
|
var type = (Type)obj.LookupGType ();
|
|
|
|
Dictionary<IntPtr, PropertyInfo> props;
|
|
if (!Properties.TryGetValue (type, out props))
|
|
return;
|
|
|
|
PropertyInfo prop;
|
|
if (!props.TryGetValue (param_spec, out prop))
|
|
return;
|
|
|
|
prop.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;
|
|
}
|
|
}
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate void d_g_type_add_interface_static(IntPtr gtype, IntPtr iface_type, ref GInterfaceInfo info);
|
|
static d_g_type_add_interface_static g_type_add_interface_static = FuncLoader.LoadFunction<d_g_type_add_interface_static>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_add_interface_static"));
|
|
|
|
protected internal static GType RegisterGType (System.Type t)
|
|
{
|
|
//this is a deprecated way of tracking a property counter,
|
|
//but we may still need it for backwards compatibility
|
|
idx = 1;
|
|
|
|
return new ClassInitializer (t).Init ();
|
|
}
|
|
|
|
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]);
|
|
}
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate IntPtr d_g_object_new(IntPtr gtype, IntPtr dummy);
|
|
static d_g_object_new g_object_new = FuncLoader.LoadFunction<d_g_object_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_new"));
|
|
|
|
struct GParameter {
|
|
public IntPtr name;
|
|
public GLib.Value val;
|
|
}
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate IntPtr d_g_object_newv(IntPtr gtype, int n_params, GParameter[] parms);
|
|
static d_g_object_newv g_object_newv = FuncLoader.LoadFunction<d_g_object_newv>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_newv"));
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate void d_g_object_ref_sink(IntPtr raw);
|
|
static d_g_object_ref_sink g_object_ref_sink = FuncLoader.LoadFunction<d_g_object_ref_sink>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_ref_sink"));
|
|
|
|
protected virtual void CreateNativeObject (string[] names, GLib.Value[] vals)
|
|
{
|
|
GType gtype = LookupGType ();
|
|
bool is_managed_subclass = GType.IsManaged (gtype);
|
|
GParameter[] parms = new GParameter [is_managed_subclass ? names.Length + 1 : names.Length];
|
|
for (int i = 0; i < names.Length; i++) {
|
|
parms [i].name = GLib.Marshaller.StringToPtrGStrdup (names [i]);
|
|
parms [i].val = vals [i];
|
|
}
|
|
|
|
if (is_managed_subclass) {
|
|
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;
|
|
|
|
lock (Objects) {
|
|
if (handle != IntPtr.Zero) {
|
|
Objects.Remove (handle);
|
|
if (tref != null) {
|
|
tref.Dispose ();
|
|
tref = null;
|
|
}
|
|
}
|
|
|
|
// All references that we get here are assumed to be owned by us. If we
|
|
// get a floating reference then we should take ownership of it by
|
|
// sinking it.
|
|
if (value != IntPtr.Zero && g_object_is_floating(value)) {
|
|
g_object_ref_sink(value);
|
|
}
|
|
|
|
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 (); }
|
|
}
|
|
|
|
public 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); }
|
|
}
|
|
|
|
public void AddNotification (string property, NotifyHandler handler)
|
|
{
|
|
AddSignalHandler ("notify::" + property, handler, typeof(NotifyArgs));
|
|
}
|
|
|
|
public void AddNotification (NotifyHandler handler)
|
|
{
|
|
AddSignalHandler ("notify", handler, typeof(NotifyArgs));
|
|
}
|
|
|
|
public void RemoveNotification (string property, NotifyHandler handler)
|
|
{
|
|
RemoveSignalHandler ("notify::" + property, handler);
|
|
}
|
|
|
|
public void RemoveNotification (NotifyHandler handler)
|
|
{
|
|
RemoveSignalHandler ("notify", handler);
|
|
}
|
|
|
|
public override int GetHashCode ()
|
|
{
|
|
return Handle.GetHashCode ();
|
|
}
|
|
|
|
System.Collections.Hashtable data;
|
|
public System.Collections.Hashtable Data {
|
|
get {
|
|
if (data == null)
|
|
data = new System.Collections.Hashtable ();
|
|
|
|
return data;
|
|
}
|
|
}
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate void d_g_object_get_property(IntPtr obj, IntPtr name, ref GLib.Value val);
|
|
static d_g_object_get_property g_object_get_property = FuncLoader.LoadFunction<d_g_object_get_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_get_property"));
|
|
|
|
public 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;
|
|
}
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate void d_g_object_set_property(IntPtr obj, IntPtr name, ref GLib.Value val);
|
|
static d_g_object_set_property g_object_set_property = FuncLoader.LoadFunction<d_g_object_set_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_set_property"));
|
|
|
|
public 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);
|
|
}
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate void d_g_object_notify(IntPtr obj, IntPtr property_name);
|
|
static d_g_object_notify g_object_notify = FuncLoader.LoadFunction<d_g_object_notify>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_notify"));
|
|
|
|
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);
|
|
}
|
|
|
|
Dictionary<string, Signal> signals;
|
|
Dictionary<string, Signal> Signals {
|
|
get {
|
|
if (signals == null)
|
|
signals = new Dictionary<string, Signal> ();
|
|
return signals;
|
|
}
|
|
}
|
|
|
|
public void AddSignalHandler (string name, Delegate handler)
|
|
{
|
|
AddSignalHandler (name, handler, typeof (EventArgs));
|
|
}
|
|
|
|
public void AddSignalHandler (string name, Delegate handler, Delegate marshaler)
|
|
{
|
|
Signal sig;
|
|
if (!Signals.TryGetValue (name, out sig)) {
|
|
sig = new Signal (this, name, marshaler);
|
|
Signals [name] = sig;
|
|
}
|
|
|
|
sig.AddDelegate (handler);
|
|
}
|
|
|
|
public void AddSignalHandler (string name, Delegate handler, Type args_type)
|
|
{
|
|
if (args_type == null)
|
|
args_type = handler.Method.GetParameters ()[1].ParameterType;
|
|
|
|
Signal sig;
|
|
if (!Signals.TryGetValue (name, out sig)) {
|
|
sig = new Signal (this, name, args_type);
|
|
Signals [name] = sig;
|
|
}
|
|
|
|
sig.AddDelegate (handler);
|
|
}
|
|
|
|
public void RemoveSignalHandler (string name, Delegate handler)
|
|
{
|
|
Signal sig;
|
|
if (Signals.TryGetValue (name, out sig))
|
|
sig.RemoveDelegate (handler);
|
|
}
|
|
|
|
protected static void OverrideVirtualMethod (GType gtype, string name, Delegate cb)
|
|
{
|
|
Signal.OverrideDefaultHandler (gtype, name, cb);
|
|
}
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
protected delegate void d_g_signal_chain_from_overridden(IntPtr args, ref GLib.Value retval);
|
|
protected static d_g_signal_chain_from_overridden g_signal_chain_from_overridden = FuncLoader.LoadFunction<d_g_signal_chain_from_overridden>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_signal_chain_from_overridden"));
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
delegate bool d_g_type_check_instance_is_a(IntPtr obj, IntPtr gtype);
|
|
static d_g_type_check_instance_is_a g_type_check_instance_is_a = FuncLoader.LoadFunction<d_g_type_check_instance_is_a>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_check_instance_is_a"));
|
|
|
|
internal static bool IsObject (IntPtr obj)
|
|
{
|
|
return g_type_check_instance_is_a (obj, GType.Object.Val);
|
|
}
|
|
|
|
public struct GTypeInstance {
|
|
public IntPtr g_class;
|
|
}
|
|
|
|
public 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));
|
|
}
|
|
|
|
// Internal representation of the wrapped ABI structure.
|
|
static public AbiStruct abi_info = new AbiStruct(new List<AbiField> {
|
|
new GLib.AbiField("g_type_instance"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, null
|
|
, "ref_count"
|
|
, (long) Marshal.OffsetOf(typeof(GObject_g_type_instanceAlign), "g_type_instance")
|
|
, 0
|
|
),
|
|
new GLib.AbiField("ref_count"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(uint)) // ref_count
|
|
, "g_type_instance"
|
|
, "qdata"
|
|
, (long) Marshal.OffsetOf(typeof(GObject_ref_countAlign), "ref_count")
|
|
, 0
|
|
),
|
|
new GLib.AbiField("qdata"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // qdata
|
|
, "ref_count"
|
|
, null
|
|
, (long) Marshal.OffsetOf(typeof(GObject_qdataAlign), "qdata")
|
|
, 0
|
|
),
|
|
}
|
|
);
|
|
//
|
|
// Internal representation of the wrapped ABI structure.
|
|
static public AbiStruct class_abi = new AbiStruct(new List<AbiField> {
|
|
new GLib.AbiField("type_class"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, null
|
|
, "construct_props"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("construct_props"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "type_class"
|
|
, "constructor_cb"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("constructor_cb"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "construct_props"
|
|
, "set_prop_cb"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("set_prop_cb"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "constructor_cb"
|
|
, "get_prop_cb"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("get_prop_cb"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "set_prop_cb"
|
|
, "dispose"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("dispose"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "get_prop_cb"
|
|
, "finalize"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("finalize"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "dispose"
|
|
, "dispatch_properties_changed"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("dispatch_properties_changed"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "finalize"
|
|
, "notify"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("notify"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "dispatch_properties_changed"
|
|
, "constructed"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("constructed"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "notify"
|
|
, "dummy1"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("dummy1"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "constructed"
|
|
, "dummy2"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("dummy2"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "dummy1"
|
|
, "dummy3"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("dummy3"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "dummy2"
|
|
, "dummy4"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("dummy3"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "dummy2"
|
|
, "dummy4"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("dummy4"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "dummy3"
|
|
, "dummy5"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("dummy5"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "dummy4"
|
|
, "dummy6"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("dummy6"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "dummy5"
|
|
, "dummy7"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
new GLib.AbiField("dummy7"
|
|
, 0
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, "dummy6"
|
|
, null
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // g_type_instance
|
|
, 0
|
|
),
|
|
}
|
|
);
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct GObject_g_type_instanceAlign
|
|
{
|
|
sbyte f1;
|
|
private IntPtr g_type_instance;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct GObject_ref_countAlign
|
|
{
|
|
sbyte f1;
|
|
private uint ref_count;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct GObject_qdataAlign
|
|
{
|
|
sbyte f1;
|
|
private IntPtr qdata;
|
|
}
|
|
// End of the ABI representation.
|
|
}
|
|
}
|
|
|