GtkSharp/glib/Object.cs
Rachel Hestilow 6857128f07 2002-06-21 Rachel Hestilow <hestilow@ximian.com>
* generator/ClassBase.cs: New base class for classes and interfaces.

	* generator/InterfaceGen.cs: Inherit from ClassBase, generate declarations.

	* generator/ObjectGen.cs: Move half of this into ClassBase.

	* generator/Method.cs: Turn all applicable Get/Set functions into .NET
	accessors. Remove redundant == overload and move into Equals, as
	it was confusing "!= null".

	* generator/Parameters.cs: Alter signature creation to accept "is_set"
	option, add support for variable arguments. Add properties "Count",
	"IsVarArgs", "VAType".

	* generator/Ctor.cs: Fixup for changes in Parameters (indenting,
	signature creation).

	* generator/Signal.cs: Support generating declarations.

	* generator/SymbolTable: Change GetObjectGen to GetClassGen.

	* glib/IWrapper.cs: Move "Handle" declaration to here, so
	both classes and interfaces can benefit from it.

	* glib/Object.cs: Inherit from IWrapper.cs

	* parser/Metadata.pm: Support attribute changes on constructors,
	methods, signals, and paramater lists.

	* parser/gapi2xml.pl: Parse init funcs for interfaces. Ignore "_"
	functions here.

	* parser/gapi_pp.pl: Remove boxed_type_register check, as it will
	be caught in the init funcs.

	* parser/Atk.metadata: Added.

	* parser/Gtk.metadata: Add all needed signal/method collision
	renames. Rename GtkEditable.Editable accessors to IsEditable,
	as .NET does not like accessors with the same name as their
	declaring type. Tag TreeStore constructor as varargs.

	* samples/ButtonApp.cs: s/EmitAdd/Add.

	* samples/Menu.cs: s/EmitAdd/Add, s/Activate/Activated.

svn path=/trunk/gtk-sharp/; revision=5394
2002-06-21 17:15:19 +00:00

231 lines
4.3 KiB
C#

// Object.cs - GObject class wrapper implementation
//
// Authors: Bob Smith <bob@thestuff.net>
// Mike Kestner <mkestner@speakeasy.net>
//
// (c) 2001 Bob Smith and Mike Kestner
namespace GLib {
using System;
using System.Collections;
using System.ComponentModel;
using System.Runtime.InteropServices;
/// <summary>
/// Object Class
/// </summary>
///
/// <remarks>
/// Wrapper class for GObject.
/// </remarks>
public class Object : IWrapper {
// Private class and instance members
IntPtr _obj;
EventHandlerList _events;
Hashtable Data;
static Hashtable Objects = new Hashtable();
/// <summary>
/// GetObject Shared Method
/// </summary>
///
/// <remarks>
/// Used to obtain a CLI typed object associated with a
/// given raw object pointer. This method is primarily
/// used to wrap object references that are returned
/// by either the signal system or raw class methods that
/// return GObject references.
/// </remarks>
///
/// <returns>
/// The wrapper instance.
/// </returns>
public static Object GetObject(IntPtr o)
{
Object obj = (Object)Objects[(int)o];
if (obj != null) return obj;
return null; //FIXME: Call TypeParser here eventually.
}
/// <summary>
/// Object Constructor
/// </summary>
///
/// <remarks>
/// Dummy constructor needed for derived classes.
/// </remarks>
public Object () {}
/// <summary>
/// Object Constructor
/// </summary>
///
/// <remarks>
/// Creates an object from a raw object reference.
/// </remarks>
public Object (IntPtr raw)
{
Raw = raw;
}
/// <summary>
/// Raw Property
/// </summary>
///
/// <remarks>
/// The raw GObject reference associated with this wrapper.
/// Only subclasses of Object can access this read/write
/// property. For public read-only access, use the
/// Handle property.
/// </remarks>
protected IntPtr Raw {
get {
return _obj;
}
set {
Objects [value] = this;
_obj = value;
}
}
/// <summary>
/// Handle Property
/// </summary>
///
/// <remarks>
/// The raw GObject reference associated with this object.
/// Subclasses can use Raw property for read/write
/// access.
/// </remarks>
public IntPtr Handle {
get {
return _obj;
}
set {
_obj = value;
}
}
/// <summary>
/// EventList Property
/// </summary>
///
/// <remarks>
/// A list object containing all the events for this
/// object indexed by the Gtk+ signal name.
/// </remarks>
protected EventHandlerList EventList {
get {
if (_events == null)
_events = new EventHandlerList ();
return _events;
}
}
/// <summary>
/// Equals Method
/// </summary>
///
/// <remarks>
/// Checks equivalence of two Objects.
/// </remarks>
public override bool Equals (object o)
{
if (!(o is Object))
return false;
return (Handle == ((Object) o).Handle);
}
/// <summary>
/// GetHashCode Method
/// </summary>
///
/// <remarks>
/// Calculates a hashing value.
/// </remarks>
public override int GetHashCode ()
{
return Handle.GetHashCode ();
}
/// <summary>
/// GetData Method
/// </summary>
///
/// <remarks>
/// Accesses arbitrary data storage on the Object.
/// </remarks>
public object GetData (string key)
{
if (Data == null)
return String.Empty;
return Data [key];
}
/// <summary>
/// SetData Method
/// </summary>
///
/// <remarks>
/// Stores arbitrary data on the Object.
/// </remarks>
public void SetData (string key, object val)
{
if (Data == null)
Data = new Hashtable ();
Data [key] = val;
}
/// <summary>
/// GetProperty Method
/// </summary>
///
/// <remarks>
/// Accesses a Value Property.
/// </remarks>
[DllImport("gobject-2.0")]
static extern void g_object_get_property (
IntPtr obj, string name, IntPtr val);
public void GetProperty (String name, GLib.Value val)
{
g_object_get_property (Raw, name, val.Handle);
}
/// <summary>
/// SetProperty Method
/// </summary>
///
/// <remarks>
/// Accesses a Value Property.
/// </remarks>
[DllImport("gobject-2.0")]
static extern void g_object_set_property (
IntPtr obj, string name, IntPtr val);
public void SetProperty (String name, GLib.Value val)
{
g_object_set_property (Raw, name, val.Handle);
}
}
}