2001-09-19 04:04:57 +02:00
|
|
|
// Object.cs - GObject class wrapper implementation
|
|
|
|
//
|
2003-07-23 19:19:21 +02:00
|
|
|
// Authors: Mike Kestner <mkestner@speakeasy.net>
|
2001-09-19 04:04:57 +02:00
|
|
|
//
|
2004-05-27 18:35:21 +02:00
|
|
|
// Copyright (c) 2001-2003 Mike Kestner
|
2005-08-15 17:56:16 +02:00
|
|
|
// Copyright (c) 2004-2005 Novell, Inc.
|
2004-06-25 20:42:19 +02:00
|
|
|
//
|
|
|
|
// 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.
|
|
|
|
|
2004-03-16 20:43:04 +01:00
|
|
|
|
2001-09-19 13:37:15 +02:00
|
|
|
namespace GLib {
|
2001-09-19 04:04:57 +02:00
|
|
|
|
|
|
|
using System;
|
2001-09-20 06:03:27 +02:00
|
|
|
using System.Collections;
|
2001-09-19 13:37:15 +02:00
|
|
|
using System.ComponentModel;
|
2002-12-25 01:36:00 +01:00
|
|
|
using System.Reflection;
|
2001-09-19 04:04:57 +02:00
|
|
|
using System.Runtime.InteropServices;
|
2005-08-24 02:36:57 +02:00
|
|
|
using System.Text;
|
2001-09-19 04:04:57 +02:00
|
|
|
|
2002-09-04 07:25:58 +02:00
|
|
|
public class Object : IWrapper, IDisposable {
|
2001-09-27 20:39:53 +02:00
|
|
|
|
|
|
|
IntPtr _obj;
|
2002-09-04 07:25:58 +02:00
|
|
|
bool disposed = false;
|
2003-07-04 09:13:19 +02:00
|
|
|
Hashtable data;
|
2001-09-27 20:39:53 +02:00
|
|
|
static Hashtable Objects = new Hashtable();
|
2005-05-31 21:22:58 +02:00
|
|
|
static ArrayList PendingDestroys = new ArrayList ();
|
2003-03-15 21:49:37 +01:00
|
|
|
static bool idle_queued;
|
2001-09-27 20:39:53 +02:00
|
|
|
|
2002-09-04 07:25:58 +02:00
|
|
|
~Object ()
|
|
|
|
{
|
|
|
|
Dispose ();
|
|
|
|
}
|
|
|
|
|
2003-07-23 19:19:21 +02:00
|
|
|
[DllImport("libgobject-2.0-0.dll")]
|
|
|
|
static extern void g_object_unref (IntPtr raw);
|
|
|
|
|
2003-03-15 21:49:37 +01:00
|
|
|
static bool PerformQueuedUnrefs ()
|
|
|
|
{
|
|
|
|
Object [] objects;
|
|
|
|
|
|
|
|
lock (PendingDestroys){
|
|
|
|
objects = new Object [PendingDestroys.Count];
|
|
|
|
PendingDestroys.CopyTo (objects, 0);
|
|
|
|
PendingDestroys.Clear ();
|
|
|
|
}
|
|
|
|
lock (typeof (Object))
|
|
|
|
idle_queued = false;
|
|
|
|
|
|
|
|
foreach (Object o in objects){
|
|
|
|
if (o._obj == IntPtr.Zero)
|
|
|
|
continue;
|
2003-12-03 21:23:25 +01:00
|
|
|
|
2005-05-10 13:30:12 +02:00
|
|
|
try {
|
|
|
|
g_object_unref (o._obj);
|
|
|
|
} catch (Exception e) {
|
2005-05-12 21:06:36 +02:00
|
|
|
Console.WriteLine ("Exception while disposing a " + o + " in Gtk#");
|
2005-05-10 13:30:12 +02:00
|
|
|
throw e;
|
|
|
|
}
|
2005-05-31 21:22:58 +02:00
|
|
|
Objects.Remove (o._obj);
|
2003-03-15 21:49:37 +01:00
|
|
|
o._obj = IntPtr.Zero;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-05-12 02:42:21 +02:00
|
|
|
public virtual void Dispose ()
|
2002-09-04 07:25:58 +02:00
|
|
|
{
|
|
|
|
if (disposed)
|
|
|
|
return;
|
|
|
|
|
|
|
|
disposed = true;
|
2003-03-15 21:49:37 +01:00
|
|
|
lock (PendingDestroys){
|
2005-05-31 21:22:58 +02:00
|
|
|
PendingDestroys.Add (this);
|
2003-03-15 21:49:37 +01:00
|
|
|
lock (typeof (Object)){
|
|
|
|
if (!idle_queued){
|
|
|
|
Idle.Add (new IdleHandler (PerformQueuedUnrefs));
|
|
|
|
idle_queued = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
GC.SuppressFinalize (this);
|
2002-09-04 07:25:58 +02:00
|
|
|
}
|
|
|
|
|
2003-02-22 05:34:56 +01:00
|
|
|
[DllImport("libgobject-2.0-0.dll")]
|
2002-09-12 07:21:16 +02:00
|
|
|
static extern void g_object_ref (IntPtr raw);
|
|
|
|
|
2003-07-23 19:19:21 +02:00
|
|
|
public static Object GetObject(IntPtr o, bool owned_ref)
|
2001-09-19 06:47:48 +02:00
|
|
|
{
|
2005-03-03 21:50:46 +01:00
|
|
|
if (o == IntPtr.Zero)
|
|
|
|
return null;
|
|
|
|
|
2005-08-15 17:56:16 +02:00
|
|
|
Object obj = null;
|
2003-07-23 19:19:21 +02:00
|
|
|
WeakReference weak_ref = Objects[o] as WeakReference;
|
2005-05-31 21:22:58 +02:00
|
|
|
|
2005-08-15 17:56:16 +02:00
|
|
|
if (weak_ref != null && weak_ref.IsAlive)
|
|
|
|
obj = weak_ref.Target as Object;
|
|
|
|
|
|
|
|
if (obj == null)
|
|
|
|
obj = Objects[o] as Object;
|
2005-05-31 21:22:58 +02:00
|
|
|
|
2005-08-15 17:56:16 +02:00
|
|
|
if (obj != null && obj._obj == o) {
|
|
|
|
lock (PendingDestroys)
|
|
|
|
PendingDestroys.Remove (obj);
|
2003-07-23 19:19:21 +02:00
|
|
|
if (owned_ref)
|
|
|
|
g_object_unref (obj._obj);
|
|
|
|
return obj;
|
2003-04-09 19:50:51 +02:00
|
|
|
}
|
|
|
|
|
2004-05-28 18:59:21 +02:00
|
|
|
obj = GLib.ObjectManager.CreateObject(o);
|
2003-07-23 19:19:21 +02:00
|
|
|
if (obj == null)
|
|
|
|
return null;
|
|
|
|
|
|
|
|
if (!owned_ref)
|
|
|
|
g_object_ref (obj.Handle);
|
|
|
|
Objects [o] = new WeakReference (obj);
|
|
|
|
return obj;
|
2001-09-19 04:04:57 +02:00
|
|
|
}
|
2001-09-20 06:03:27 +02:00
|
|
|
|
2003-12-10 23:56:49 +01:00
|
|
|
public static Object GetObject(IntPtr o)
|
|
|
|
{
|
|
|
|
return GetObject (o, false);
|
|
|
|
}
|
|
|
|
|
2003-12-30 23:09:42 +01:00
|
|
|
private static void ConnectDefaultHandlers (GType gtype, System.Type t)
|
|
|
|
{
|
2004-06-05 03:01:07 +02:00
|
|
|
foreach (MethodInfo minfo in t.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly)) {
|
2003-12-30 23:09:42 +01:00
|
|
|
MethodInfo baseinfo = minfo.GetBaseDefinition ();
|
|
|
|
if (baseinfo == minfo)
|
|
|
|
continue;
|
|
|
|
|
2005-01-14 20:54:07 +01:00
|
|
|
foreach (object attr in baseinfo.GetCustomAttributes (typeof (DefaultSignalHandlerAttribute), false)) {
|
2003-12-30 23:09:42 +01:00
|
|
|
DefaultSignalHandlerAttribute sigattr = attr as DefaultSignalHandlerAttribute;
|
|
|
|
MethodInfo connector = sigattr.Type.GetMethod (sigattr.ConnectionMethod, BindingFlags.Static | BindingFlags.NonPublic);
|
|
|
|
object[] parms = new object [1];
|
|
|
|
parms [0] = gtype;
|
|
|
|
connector.Invoke (null, parms);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2004-12-23 23:59:59 +01:00
|
|
|
private static void InvokeClassInitializers (GType gtype, System.Type t)
|
|
|
|
{
|
|
|
|
object[] parms = {gtype, t};
|
|
|
|
BindingFlags flags = BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy;
|
|
|
|
foreach (MethodInfo minfo in t.GetMethods(flags))
|
2005-03-15 17:40:24 +01:00
|
|
|
if (minfo.IsDefined (typeof (ClassInitializerAttribute), true))
|
2004-12-23 23:59:59 +01:00
|
|
|
minfo.Invoke (null, parms);
|
|
|
|
}
|
|
|
|
|
2004-12-07 20:03:55 +01:00
|
|
|
[DllImport("glibsharpglue-2")]
|
2005-03-08 22:28:08 +01:00
|
|
|
static extern IntPtr gtksharp_register_type (IntPtr name, IntPtr parent_type);
|
2002-12-25 01:36:00 +01:00
|
|
|
|
2005-08-24 02:36:57 +02:00
|
|
|
|
|
|
|
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 ();
|
|
|
|
}
|
|
|
|
|
2004-05-17 19:52:00 +02:00
|
|
|
protected static GType RegisterGType (System.Type t)
|
2002-12-25 01:36:00 +01:00
|
|
|
{
|
2004-05-07 15:42:59 +02:00
|
|
|
GType parent_gtype = LookupGType (t.BaseType);
|
2005-08-24 02:36:57 +02:00
|
|
|
string name = BuildEscapedName (t);
|
2005-03-08 22:28:08 +01:00
|
|
|
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
|
|
|
|
GType gtype = new GType (gtksharp_register_type (native_name, parent_gtype.Val));
|
|
|
|
GLib.Marshaller.Free (native_name);
|
2005-05-04 18:54:24 +02:00
|
|
|
GLib.GType.Register (gtype, t);
|
2003-12-30 23:09:42 +01:00
|
|
|
ConnectDefaultHandlers (gtype, t);
|
2004-12-23 23:59:59 +01:00
|
|
|
InvokeClassInitializers (gtype, t);
|
2004-04-07 21:15:01 +02:00
|
|
|
g_types[t] = gtype;
|
2003-12-30 23:09:42 +01:00
|
|
|
return gtype;
|
2002-12-25 01:36:00 +01:00
|
|
|
}
|
|
|
|
|
2004-04-07 21:15:01 +02:00
|
|
|
|
|
|
|
static Hashtable g_types = new Hashtable ();
|
2004-05-07 15:42:59 +02:00
|
|
|
|
2004-05-17 19:52:00 +02:00
|
|
|
protected GType LookupGType ()
|
2004-05-07 15:42:59 +02:00
|
|
|
{
|
|
|
|
return LookupGType (GetType ());
|
|
|
|
}
|
|
|
|
|
2005-05-04 18:54:24 +02:00
|
|
|
protected internal static GType LookupGType (System.Type t)
|
2004-04-07 21:15:01 +02:00
|
|
|
{
|
2004-05-07 15:42:59 +02:00
|
|
|
if (g_types.Contains (t))
|
2004-04-07 21:15:01 +02:00
|
|
|
return (GType) g_types [t];
|
|
|
|
|
|
|
|
PropertyInfo pi = t.GetProperty ("GType", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public);
|
|
|
|
if (pi != null)
|
|
|
|
return (GType) pi.GetValue (null, null);
|
|
|
|
|
|
|
|
return RegisterGType (t);
|
|
|
|
}
|
2002-02-03 04:44:10 +01:00
|
|
|
|
2004-05-17 19:52:00 +02:00
|
|
|
protected Object (IntPtr raw)
|
2002-02-03 04:44:10 +01:00
|
|
|
{
|
2002-02-19 20:46:44 +01:00
|
|
|
Raw = raw;
|
2002-02-03 04:44:10 +01:00
|
|
|
}
|
2001-09-19 04:04:57 +02:00
|
|
|
|
2003-02-22 05:34:56 +01:00
|
|
|
[DllImport("libgobject-2.0-0.dll")]
|
2003-12-15 17:59:25 +01:00
|
|
|
static extern IntPtr g_object_new (IntPtr gtype, IntPtr dummy);
|
2002-12-25 01:36:00 +01:00
|
|
|
|
2004-11-09 15:22:39 +01:00
|
|
|
[Obsolete]
|
2003-12-15 17:59:25 +01:00
|
|
|
protected Object (GType gtype)
|
2002-12-25 01:36:00 +01:00
|
|
|
{
|
2003-12-15 17:59:25 +01:00
|
|
|
Raw = g_object_new (gtype.Val, IntPtr.Zero);
|
2002-12-25 01:36:00 +01:00
|
|
|
}
|
|
|
|
|
2004-12-07 20:03:55 +01:00
|
|
|
[DllImport("glibsharpglue-2")]
|
2005-03-08 22:28:08 +01:00
|
|
|
static extern IntPtr gtksharp_object_newv (IntPtr gtype, int n_params, IntPtr[] names, GLib.Value[] vals);
|
2004-05-07 15:42:59 +02:00
|
|
|
|
2004-11-09 15:22:39 +01:00
|
|
|
protected virtual void CreateNativeObject (string[] names, GLib.Value[] vals)
|
2004-05-07 15:42:59 +02:00
|
|
|
{
|
2005-03-08 22:28:08 +01:00
|
|
|
IntPtr[] native_names = new IntPtr [names.Length];
|
|
|
|
for (int i = 0; i < names.Length; i++)
|
|
|
|
native_names [i] = GLib.Marshaller.StringToPtrGStrdup (names [i]);
|
|
|
|
Raw = gtksharp_object_newv (LookupGType ().Val, names.Length, native_names, vals);
|
2005-08-15 17:56:16 +02:00
|
|
|
Objects [_obj] = this;
|
2005-03-08 22:28:08 +01:00
|
|
|
foreach (IntPtr p in native_names)
|
|
|
|
GLib.Marshaller.Free (p);
|
2004-05-07 15:42:59 +02:00
|
|
|
}
|
|
|
|
|
2002-11-10 11:09:05 +01:00
|
|
|
protected virtual IntPtr Raw {
|
2001-09-19 13:37:15 +02:00
|
|
|
get {
|
2001-09-19 04:04:57 +02:00
|
|
|
return _obj;
|
|
|
|
}
|
2001-09-19 13:37:15 +02:00
|
|
|
set {
|
2004-07-25 01:36:39 +02:00
|
|
|
if (_obj != IntPtr.Zero)
|
|
|
|
Objects.Remove (_obj);
|
2001-09-19 04:04:57 +02:00
|
|
|
_obj = value;
|
2004-06-09 19:53:05 +02:00
|
|
|
if (value == IntPtr.Zero)
|
|
|
|
return;
|
|
|
|
Objects [value] = new WeakReference (this);
|
2001-09-19 04:04:57 +02:00
|
|
|
}
|
2002-11-10 11:09:05 +01:00
|
|
|
}
|
2001-09-19 04:04:57 +02:00
|
|
|
|
2004-05-27 18:35:21 +02:00
|
|
|
public static GLib.GType GType {
|
2002-08-09 05:56:27 +02:00
|
|
|
get {
|
2004-05-17 19:52:00 +02:00
|
|
|
return GType.Object;
|
2002-08-09 05:56:27 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-12-07 20:03:55 +01:00
|
|
|
[DllImport("glibsharpglue-2")]
|
2003-12-03 21:23:25 +01:00
|
|
|
static extern IntPtr gtksharp_get_type_name (IntPtr raw);
|
|
|
|
|
2004-05-17 19:52:00 +02:00
|
|
|
protected string TypeName {
|
2003-12-03 21:23:25 +01:00
|
|
|
get {
|
2005-03-08 22:28:08 +01:00
|
|
|
return Marshaller.Utf8PtrToString (gtksharp_get_type_name (Raw));
|
2003-12-03 21:23:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-05-17 19:52:00 +02:00
|
|
|
internal GLib.GType NativeType {
|
2004-04-12 17:54:57 +02:00
|
|
|
get {
|
2004-05-18 07:06:10 +02:00
|
|
|
return LookupGType ();
|
2004-04-12 17:54:57 +02:00
|
|
|
}
|
2002-11-18 19:55:39 +01:00
|
|
|
}
|
|
|
|
|
2001-10-07 02:41:52 +02:00
|
|
|
public IntPtr Handle {
|
|
|
|
get {
|
|
|
|
return _obj;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-03-16 20:43:04 +01:00
|
|
|
Hashtable before_signals;
|
2005-02-02 22:57:15 +01:00
|
|
|
|
|
|
|
[Obsolete ("Replaced by GLib.Signal marshaling mechanism.")]
|
2004-03-16 20:43:04 +01:00
|
|
|
protected Hashtable BeforeSignals {
|
|
|
|
get {
|
|
|
|
if (before_signals == null)
|
|
|
|
before_signals = new Hashtable ();
|
|
|
|
return before_signals;
|
|
|
|
}
|
|
|
|
}
|
2001-09-27 20:39:53 +02:00
|
|
|
|
2004-03-16 20:43:04 +01:00
|
|
|
Hashtable after_signals;
|
2005-02-02 22:57:15 +01:00
|
|
|
[Obsolete ("Replaced by GLib.Signal marshaling mechanism.")]
|
2004-03-16 20:43:04 +01:00
|
|
|
protected Hashtable AfterSignals {
|
2001-09-19 13:37:15 +02:00
|
|
|
get {
|
2004-03-16 20:43:04 +01:00
|
|
|
if (after_signals == null)
|
|
|
|
after_signals = new Hashtable ();
|
|
|
|
return after_signals;
|
2001-09-19 04:04:57 +02:00
|
|
|
}
|
|
|
|
}
|
2001-09-19 06:47:48 +02:00
|
|
|
|
2004-03-16 20:43:04 +01:00
|
|
|
EventHandlerList before_handlers;
|
2005-02-02 22:57:15 +01:00
|
|
|
[Obsolete ("Replaced by GLib.Signal marshaling mechanism.")]
|
2004-03-16 20:43:04 +01:00
|
|
|
protected EventHandlerList BeforeHandlers {
|
|
|
|
get {
|
|
|
|
if (before_handlers == null)
|
|
|
|
before_handlers = new EventHandlerList ();
|
|
|
|
return before_handlers;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EventHandlerList after_handlers;
|
2005-02-02 22:57:15 +01:00
|
|
|
[Obsolete ("Replaced by GLib.Signal marshaling mechanism.")]
|
2004-03-16 20:43:04 +01:00
|
|
|
protected EventHandlerList AfterHandlers {
|
|
|
|
get {
|
|
|
|
if (after_handlers == null)
|
|
|
|
after_handlers = new EventHandlerList ();
|
|
|
|
return after_handlers;
|
|
|
|
}
|
|
|
|
}
|
2001-10-31 02:31:05 +01:00
|
|
|
|
2005-03-25 18:57:15 +01:00
|
|
|
[CDeclCallback]
|
2005-02-02 22:57:15 +01:00
|
|
|
delegate void NotifyDelegate (IntPtr handle, IntPtr pspec, IntPtr gch);
|
|
|
|
|
|
|
|
void NotifyCallback (IntPtr handle, IntPtr pspec, IntPtr gch)
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2005-01-28 17:44:30 +01:00
|
|
|
void ConnectNotification (string signal, NotifyHandler handler)
|
|
|
|
{
|
2005-02-02 22:57:15 +01:00
|
|
|
Signal sig = Signal.Lookup (this, signal, new NotifyDelegate (NotifyCallback));
|
|
|
|
sig.AddDelegate (handler);
|
2005-01-28 17:44:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2005-02-02 22:57:15 +01:00
|
|
|
Signal sig = Signal.Lookup (this, signal, new NotifyDelegate (NotifyCallback));
|
|
|
|
sig.RemoveDelegate (handler);
|
2005-01-28 17:44:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
public void RemoveNotification (string property, NotifyHandler handler)
|
|
|
|
{
|
|
|
|
DisconnectNotification ("notify::" + property, handler);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void RemoveNotification (NotifyHandler handler)
|
|
|
|
{
|
|
|
|
DisconnectNotification ("notify", handler);
|
|
|
|
}
|
|
|
|
|
2001-10-31 02:31:05 +01:00
|
|
|
public override int GetHashCode ()
|
|
|
|
{
|
|
|
|
return Handle.GetHashCode ();
|
|
|
|
}
|
|
|
|
|
2004-12-30 19:59:09 +01:00
|
|
|
[Obsolete("Can cause instability due to garbage collection of GLib.Objects.")]
|
2003-07-04 09:13:19 +02:00
|
|
|
public Hashtable Data {
|
|
|
|
get {
|
|
|
|
if (data == null)
|
|
|
|
data = new Hashtable ();
|
|
|
|
|
|
|
|
return data;
|
|
|
|
}
|
2001-09-19 04:04:57 +02:00
|
|
|
}
|
2001-09-20 06:03:27 +02:00
|
|
|
|
2005-03-12 23:19:44 +01:00
|
|
|
protected Hashtable PersistentData {
|
|
|
|
get {
|
|
|
|
return WeakObject.Lookup (Handle).Data;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-02-22 05:34:56 +01:00
|
|
|
[DllImport("libgobject-2.0-0.dll")]
|
2005-03-08 22:28:08 +01:00
|
|
|
static extern void g_object_get_property (IntPtr obj, IntPtr name, ref GLib.Value val);
|
2004-03-16 20:43:04 +01:00
|
|
|
|
2004-04-12 17:54:57 +02:00
|
|
|
protected GLib.Value GetProperty (string name)
|
2001-09-28 20:23:14 +02:00
|
|
|
{
|
2004-04-12 17:54:57 +02:00
|
|
|
Value val = new Value (this, name);
|
2005-03-08 22:28:08 +01:00
|
|
|
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
|
|
|
|
g_object_get_property (Raw, native_name, ref val);
|
|
|
|
GLib.Marshaller.Free (native_name);
|
2004-04-12 17:54:57 +02:00
|
|
|
return val;
|
2001-09-28 20:23:14 +02:00
|
|
|
}
|
|
|
|
|
2003-02-22 05:34:56 +01:00
|
|
|
[DllImport("libgobject-2.0-0.dll")]
|
2005-03-08 22:28:08 +01:00
|
|
|
static extern void g_object_set_property (IntPtr obj, IntPtr name, ref GLib.Value val);
|
2004-03-16 20:43:04 +01:00
|
|
|
|
2004-04-12 17:54:57 +02:00
|
|
|
protected void SetProperty (string name, GLib.Value val)
|
2002-01-12 03:08:16 +01:00
|
|
|
{
|
2005-03-08 22:28:08 +01:00
|
|
|
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
|
|
|
|
g_object_set_property (Raw, native_name, ref val);
|
|
|
|
GLib.Marshaller.Free (native_name);
|
2002-01-12 03:08:16 +01:00
|
|
|
}
|
|
|
|
|
2004-12-07 20:03:55 +01:00
|
|
|
[DllImport("glibsharpglue-2")]
|
2005-03-08 22:28:08 +01:00
|
|
|
static extern void gtksharp_override_virtual_method (IntPtr gtype, IntPtr name, Delegate cb);
|
2003-12-15 17:59:25 +01:00
|
|
|
|
|
|
|
protected static void OverrideVirtualMethod (GType gtype, string name, Delegate cb)
|
|
|
|
{
|
2005-03-08 22:28:08 +01:00
|
|
|
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
|
|
|
|
gtksharp_override_virtual_method (gtype.Val, native_name, cb);
|
|
|
|
GLib.Marshaller.Free (native_name);
|
2003-12-15 17:59:25 +01:00
|
|
|
}
|
2003-12-10 23:56:49 +01:00
|
|
|
|
2003-12-09 06:01:22 +01:00
|
|
|
[DllImport("libgobject-2.0-0.dll")]
|
2004-04-12 17:54:57 +02:00
|
|
|
protected static extern void g_signal_chain_from_overridden (IntPtr args, ref GLib.Value retval);
|
2003-12-09 06:01:22 +01:00
|
|
|
|
2004-12-07 20:03:55 +01:00
|
|
|
[DllImport("glibsharpglue-2")]
|
2002-09-01 06:46:38 +02:00
|
|
|
static extern bool gtksharp_is_object (IntPtr obj);
|
|
|
|
|
|
|
|
internal static bool IsObject (IntPtr obj)
|
|
|
|
{
|
|
|
|
return gtksharp_is_object (obj);
|
|
|
|
}
|
2002-11-10 11:09:05 +01:00
|
|
|
|
2004-12-07 20:03:55 +01:00
|
|
|
[DllImport("glibsharpglue-2")]
|
2002-11-10 11:09:05 +01:00
|
|
|
static extern int gtksharp_object_get_ref_count (IntPtr obj);
|
|
|
|
|
2004-05-17 19:52:00 +02:00
|
|
|
protected int RefCount {
|
2002-11-10 11:09:05 +01:00
|
|
|
get {
|
|
|
|
return gtksharp_object_get_ref_count (Handle);
|
|
|
|
}
|
|
|
|
}
|
2001-09-19 04:04:57 +02:00
|
|
|
}
|
|
|
|
}
|