GtkSharp/glib/Object.cs

727 lines
23 KiB
C#
Raw Normal View History

// Object.cs - GObject class wrapper implementation
//
// Authors: Mike Kestner <mkestner@speakeasy.net>
//
// 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.Generic;
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;
2011-11-20 18:41:56 +00:00
static uint idx = 1;
static Dictionary<IntPtr, ToggleRef> Objects = new Dictionary<IntPtr, ToggleRef>();
~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 ();
}
public static bool WarnOnFinalize { get; set; }
[DllImport ("libgobject-2.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr g_object_ref (IntPtr raw);
[DllImport ("libgobject-2.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void g_object_unref (IntPtr raw);
public static Object GetObject(IntPtr o, bool owned_ref)
{
if (o == IntPtr.Zero)
return null;
Object obj = null;
ToggleRef toggle_ref;
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;
}
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 InvokeTypeInitializers (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);
}
}
// 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;
}
}
2011-11-20 18:41:56 +00:00
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;
}
[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;
}
}
[DllImport ("libgobject-2.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr g_param_spec_get_name (IntPtr pspec);
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);
bool construct_needed = true;
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;
Object o = (GLib.Object) gch.Target;
o.Raw = raw;
construct_needed = false;
break;
}
}
if (construct_needed)
GetObject (raw, false);
return raw;
}
2011-11-20 18:41:56 +00:00
[DllImport ("libgobject-2.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void g_object_class_override_property (IntPtr klass, uint prop_id, IntPtr name);
public static void OverrideProperty (IntPtr declaring_class, string name)
{
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
g_object_class_override_property (declaring_class, idx, native_name);
idx++;
}
[DllImport ("libgobject-2.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr g_object_class_find_property (IntPtr klass, IntPtr name);
static IntPtr FindClassProperty (GType type, string name)
{
IntPtr g_iface = type.GetDefaultInterfacePtr ();
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
return g_object_class_find_property (g_iface, native_name);
}
[DllImport ("libgobject-2.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr g_object_interface_find_property (IntPtr klass, IntPtr name);
static IntPtr FindInterfaceProperty (GType type, string name)
{
IntPtr g_iface = type.GetDefaultInterfacePtr ();
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
return g_object_interface_find_property (g_iface, native_name);
}
[DllImport ("libgobject-2.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
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.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;
}
2011-11-20 18:41:56 +00:00
static void AddProperties (GType gtype, System.Type t, bool register_instance_prop, ref bool handlers_overridden)
{
if (register_instance_prop) {
IntPtr declaring_class = gtype.GetClassPtr ();
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++;
}
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)));
if (!handlers_overridden) {
IntPtr class_ptr = gtype.GetClassPtr ();
GObjectClass gobject_class = (GObjectClass) Marshal.PtrToStructure (class_ptr, typeof (GObjectClass));
gobject_class.get_prop_cb = GetPropertyHandler;
gobject_class.set_prop_cb = SetPropertyHandler;
Marshal.StructureToPtr (gobject_class, class_ptr, false);
handlers_overridden = 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, 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)
{
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)
{
2011-11-20 18:41:56 +00:00
// FIXME: Here is a big quick hack to avoid race condition when trying to set up adjustment with contructor
// Because Raw is set too late
if (param_spec != IntPtr.Zero) {
ParamSpec foo = new ParamSpec(param_spec);
if (foo.Name == "gtk-sharp-managed-instance") {
GCHandle gch = (GCHandle) (IntPtr) value.Val;
Object o = (GLib.Object) gch.Target;
o.Raw = handle;
}
}
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;
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;
}
}
[DllImport ("libgobject-2.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void g_type_add_interface_static (IntPtr gtype, IntPtr iface_type, ref GInterfaceInfo info);
2011-11-20 18:41:56 +00:00
static void AddInterfaces (GType gtype, Type t, ref bool handlers_overridden)
{
foreach (Type iface in t.GetInterfaces ()) {
2011-11-20 18:41:56 +00:00
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;
2011-11-20 18:41:56 +00:00
if (!handlers_overridden) {
IntPtr class_ptr = gtype.GetClassPtr ();
GObjectClass gobject_class = (GObjectClass) Marshal.PtrToStructure (class_ptr, typeof (GObjectClass));
gobject_class.get_prop_cb = GetPropertyHandler;
gobject_class.set_prop_cb = SetPropertyHandler;
Marshal.StructureToPtr (gobject_class, class_ptr, false);
handlers_overridden = true;
}
if (!iface.IsAssignableFrom (t.BaseType)) {
GInterfaceInfo info = adapter.Info;
info.Data = gtype.GetClassPtr ();
//FIXME: overiding prop is done inside the init of interface adapter
// not sure that it is the good solution but
// it is the only one I found without exception or loop
g_type_add_interface_static (gtype.Val, adapter.GType.Val, ref info);
}
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 = t.GetProperty (p.Name, BindingFlags.Public | BindingFlags.Instance);
2011-11-20 18:41:56 +00:00
if (declared_prop == null)
continue;
IntPtr param_spec = FindInterfaceProperty (adapter.GType, property_attr.Name);
Dictionary<IntPtr, PropertyInfo> props;
if (!Properties.TryGetValue (t, out props)) {
props = new Dictionary<IntPtr, PropertyInfo> ();
Properties [t] = props;
}
props [param_spec] = declared_prop;
2011-11-20 18:41:56 +00:00
}
}
}
protected internal static GType RegisterGType (System.Type t)
{
GType gtype = GType.RegisterGObjectType (t);
bool is_first_subclass = gtype.GetBaseType () == gtype.GetThresholdType ();
2011-11-20 18:41:56 +00:00
if (is_first_subclass) {
IntPtr class_ptr = gtype.GetClassPtr ();
GObjectClass gobject_class = (GObjectClass) Marshal.PtrToStructure (class_ptr, typeof (GObjectClass));
gobject_class.constructor_cb = ConstructorHandler;
gobject_class.get_prop_cb = GetPropertyHandler;
gobject_class.set_prop_cb = SetPropertyHandler;
Marshal.StructureToPtr (gobject_class, class_ptr, false);
}
2011-11-20 18:41:56 +00:00
idx = 1;
bool handlers_overridden = is_first_subclass;
AddProperties (gtype, t, is_first_subclass, ref handlers_overridden);
ConnectDefaultHandlers (gtype, t);
InvokeTypeInitializers (gtype, t);
2011-11-20 18:41:56 +00:00
AddInterfaces (gtype, t, ref handlers_overridden);
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 ());
}
}
* parser/gapi2xml.pl: make note of _get_type methods for enums * */*-api.xml: Regen, adding gtype="..." to many enum types * generator/EnumGen.cs (Generate): if the enum has the "gtype" property, add a GTypeAttribute pointing to an internal FooGType class whose GType property can be used to get the enum's GType. * generator/ObjectGen.cs: s/ObjectManager.RegisterType/GType.Register/ * glib/GTypeAttribute.cs: attribute for indicating a property that will return the GType of a type (particularly for enums, which can't have GType properties added to them). * glib/GType.cs: renamed from Type.cs to match the type name (public static readonly GType ...): add a few missing types. (Register): moved from ObjectManager.RegisterType (LookupGType): moved from TypeConverter.LookupType and extended to handle GTypeAttribute. Also, fix mappings for sbyte/byte/char, and return specific GTypes for Object subclasses rather than always returning GType.Object. [Fixes #74699] (LookupType): moved from ObjectWrapper.LookupType (ToString): return the type name * glib/Object.cs (RegisterGType): s/ObjectManager.Register/GType.Register/ (LookupGType): Make this protected internal so GType can access it. * glib/ObjectManager.cs (RegisterType): deprecate in favor of GType.Register. (LookupType): moved to GType * glib/TypeConverter.cs (LookupType): now a deprecated wrapper around GType.LookupGType. * glib/Value.cs: Use GType casts rather than TypeConverter * gtk/NodeStore.cs (ScanType): * gtk/ListStore.custom (ListStore): * gtk/TreeStore.custom (TreeStore): Use (GType) cast rather than TypeConverter. Remove the error check and exception, since the cast never returns GType.Invalid. (The check probably predates GLib.ManagedValue.) * gnome/PanelAppletFactory.cs (Register): Use a GType cast rather than GLib.Object.LookupGType (which is no longer accessible after an mcs bugfix) * sample/GtkDemo/DemoIconView.cs (CreateStore): use the Type[] constructor rather than the GType[] constructor, since it translates typeof(Gdk.Pixbuf) correctly now. svn path=/trunk/gtk-sharp/; revision=44038
2005-05-04 16:54:24 +00:00
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", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr g_object_new (IntPtr gtype, IntPtr dummy);
struct GParameter {
public IntPtr name;
public GLib.Value val;
}
[DllImport ("libgobject-2.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr g_object_newv (IntPtr gtype, int n_params, GParameter[] parms);
protected virtual void CreateNativeObject (string[] names, GLib.Value[] vals)
{
GType gtype = LookupGType ();
bool is_managed_subclass = gtype.ToString ().StartsWith ("__gtksharp");
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;
if (handle != IntPtr.Zero) {
Objects.Remove (handle);
if (tref != null) {
tref.Dispose ();
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); }
}
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;
}
}
[DllImport ("libgobject-2.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
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", CallingConvention = CallingConvention.Cdecl)]
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", CallingConvention = CallingConvention.Cdecl)]
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);
}
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);
}
[DllImport ("libgobject-2.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
protected static extern void g_signal_chain_from_overridden (IntPtr args, ref GLib.Value retval);
[DllImport ("libgobject-2.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
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);
}
struct GTypeInstance {
public IntPtr g_class;
}
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));
}
}
}