# # This file is part of gtkD. # # gtkD is free software; you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation; either version 2.1 of the License, or # (at your option) any later version. # # gtkD 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 gtkD; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # ### ##### # Definitions for wrapping GObject ##### ### # structCode: GValue align(4) { Enum_GType g_type; union Data { int v_int; uint v_uint; int v_long; uint v_ulong; long v_int64; ulong v_uint64; float v_float; double v_double; void* v_pointer; }; } Data data1; Data data2; structCode: end enumCode: GType INVALID = 0<<2, NONE = 1<<2, INTERFACE = 2<<2, CHAR = 3<<2, UCHAR = 4<<2, BOOLEAN = 5<<2, INT = 6<<2, UINT = 7<<2, LONG = 8<<2, ULONG = 9<<2, INT64 = 10<<2, UINT64 = 11<<2, ENUM = 12<<2, FLAGS = 13<<2, FLOAT = 14<<2, DOUBLE = 15<<2, STRING = 16<<2, POINTER = 17<<2, BOXED = 18<<2, PARAM = 19<<2, OBJECT = 20<<2, enumCode: end wrap: gobject jsPackage: G addTypes: start public typedef extern(C) void function () GCallback; public typedef extern(C) void function (void *,void *) GClosureNotify; public typedef extern(C) void function (void*) GBoxedFreeFunc; public typedef extern(C) void* function (void*) GBoxedCopyFunc; addTypes: end registerCode: start g_type_init(); dsWrapped_GValue.BoxedDobject_get_type(); // registor our wrapper type. registerCode: end ########################################################### ### GObject ############################################### ########################################################### structWrapJS: GObject structWrapJS: GValue #structWrapJS: GType nostruct: GTypeModule nostruct: GObjectClass nostruct: GTypeInstance nostruct: GEnumClass nostruct: GParamSpecPool nostruct: GSignalQuery nostruct: GTypeValueTable file: gobject-Type-Information.html class: Type #struct: GType prefix: g_type_ import: glib.Str import: glib.Quark import: glib.bindingglibtypes import: gobject.Type import: gobject.TypePlugin #fixme - args not right! noprefix: g_type_children outFile: Type file: GTypePlugin.html struct: GTypePlugin class: TypePlugin prefix: g_type_plugin_ import: glib.Str import: gobject.Type outFile: TypePlugin file: GTypeModule.html struct: GTypeModule class: TypeModule import: glib.Str prefix: g_type_module_ import: gobject.Enums import: gobject.Flags outFile: TypeModule file: gobject-The-Base-Object-Type.html struct: GObject class: ObjectG prefix: g_object_ import: gobject.ParamSpec import: gobject.Value import: gobject.Closure import: std.gc import: glib.Str jscode: g_object_set_property Wrapped_GObject* _arg_object = cast(Wrapped_GObject*) ((cast (Dobject)othis).getStruct()); char* _arg_property_name = arglist[0].vtype == V_NULL ? null : std.string.toStringz(arglist[0].toString()); Wrapped_GValue* _arg_value = cast(Wrapped_GValue*) dsWrapped_GValue.newFromValue(arglist[1]); g_object_set_property(_arg_object,_arg_property_name,_arg_value); ret.putVundefined(); jscode: end # no get value yet... nocode: g_object_set_data_full code: start /** * Sets our main struct and passes store it on the gobject. * Add a gabage collector root to the gtk+ struct so it doesn't get collect */ public this (GObject* gObject) { this.gObject = gObject; if ( gObject !is null ) { //writefln("ObjectG.this\n"); setDataFull("GObject",cast(void*)this); } } /** * Sets a pointer on this object's has table * @param key the data identifier * @param data a pointer */ public: void setDataFull(char[] key, gpointer data) { //writefln("setData objectG=%X data=%X type %s",gObject,data,key); std.gc.addRoot(data); g_object_set_data_full(gObject, Str.toStringz(key), data, cast(GDestroyNotify)&destroyNotify); } extern(C) { static void destroyNotify(gpointer* data) { //writefln("objectg.destroy entry"); //writefln("objectg.destroy"); //writefln("removing gc.root to %s",data); std.gc.removeRoot(data); //writefln("objectg.destroy exit"); } } code: end outFile: ObjectG file: gobject-Enumeration-and-Flag-Types.html class: Enums prefix: g_enum_ noprefix: g_flags_ import: glib.Str outFile: Enums struct: GFlagsValue strictPrefix: Y class: Flags prefix: g_flags_ noprefix: g_enum_ import: glib.Str import: gobject.Flags outFile: Flags file: gobject-Boxed-Types.html class: Boxed prefix: g_ import: glib.Str outFile: Boxed # output twice ! file: gobject-Generic-values.html struct: GValue class: Value prefix: g_value_ outFile: Value #file: gobject-Generic-values.html file: gobject-Standard-Parameter-and-Value-Types.html struct: GValue class: Value prefix: g_value_ import: glib.Str import: gobject.Value import: gobject.ParamSpec import: gobject.ObjectG nocode: g_value_init nocode: g_value_reset jscode: g_value_new if (arglist.length) { Wrapped_GValue* _ret = newFromValue(arglist[0]); ret.putVobject(new dsWrapped_GValue(_ret)); } else { Wrapped_GValue* _ret = new Wrapped_GValue; ret.putVobject(new dsWrapped_GValue(_ret)); } return null; } static Dobject[uint] boxedcache; static int[uint] boxedcache_refcount; extern(C) static void* BoxedDobject_copy(void* boxed) { Dobject d = cast(Dobject) boxed; boxedcache_refcount[d.toHash()]++; return boxed; // we dont actually do any copying.. } extern(C) static void BoxedDobject_free(void* boxed) { Dobject d = cast(Dobject) boxed; boxedcache_refcount[d.toHash()]--; if (boxedcache_refcount[d.toHash()] < 1) { boxedcache_refcount.remove(d.toHash()); boxedcache.remove(d.toHash()); } return; // we dont actually do any copying.. } static Enum_GType BoxedDobject_get_type() { static Enum_GType type = cast(Enum_GType)0; if (type != 0) { return type; } type = g_boxed_type_register_static("Dobject", cast(GBoxedCopyFunc) &BoxedDobject_copy,cast(GBoxedFreeFunc) &BoxedDobject_free); return type; } static Wrapped_GValue* BoxedDobject_toGValue(Dobject d) { Wrapped_GValue* ret = new Wrapped_GValue; g_value_init(ret, BoxedDobject_get_type()); boxedcache[d.toHash()] = d; boxedcache_refcount[d.toHash()] = 1; g_value_set_boxed(ret, cast(void*) d); return ret; } // convert a dmdscript value into a GValue - suggested is to be used by the // static Wrapped_GValue* newFromValue(Value _arg_value, Enum_GType suggested=cast(Enum_GType)0) { Wrapped_GValue* _ret = new Wrapped_GValue; if (!suggested) { switch(_arg_value.vtype) { case V_NONE: case V_UNDEFINED: case V_NULL: suggested = Enum_GType.STRING; break; case V_BOOLEAN: suggested = Enum_GType.BOOLEAN; break; case V_NUMBER: suggested = Enum_GType.LONG; break; case V_STRING: suggested = Enum_GType.STRING; break; case V_OBJECT: char[] cname = std.string.replace(_arg_value.toObject().classname, ".", ""); if (g_type_from_name(std.string.toStringz(cname)) > 0) { suggested = Enum_GType.OBJECT; break; } suggested = Enum_GType.BOXED; break; default: suggested = Enum_GType.STRING; break; } } switch (suggested) { case Enum_GType.BOOLEAN: g_value_init(_ret, Enum_GType.BOOLEAN); g_value_set_boolean(_ret, cast(int) (_arg_value.toBoolean())); return _ret; //CHAR = 3<<2, //UCHAR = 4<<2, case Enum_GType.INT: g_value_init(_ret, Enum_GType.INT); g_value_set_int(_ret, cast(int) (_arg_value.toNumber())); return _ret; case Enum_GType.UINT: g_value_init(_ret, Enum_GType.UINT); g_value_set_uint(_ret, cast(uint) (_arg_value.toNumber())); return _ret; case Enum_GType.LONG : g_value_init(_ret, Enum_GType.LONG); g_value_set_long(_ret, cast(int) (_arg_value.toNumber())); return _ret; case Enum_GType.ULONG : g_value_init(_ret, Enum_GType.ULONG); g_value_set_ulong(_ret, cast(uint) (_arg_value.toNumber())); return _ret; case Enum_GType.INT64: g_value_init(_ret, Enum_GType.INT64); g_value_set_int64(_ret, cast(long) (_arg_value.toNumber())); return _ret; case Enum_GType.UINT64: g_value_init(_ret, Enum_GType.UINT64); g_value_set_int64(_ret, cast(ulong) (_arg_value.toNumber())); return _ret; //Enum_GType.ENUM //Enum_GType.FLAGS case Enum_GType.FLOAT: g_value_init(_ret, Enum_GType.FLOAT); g_value_set_float(_ret, cast(float) (_arg_value.toNumber())); return _ret; case Enum_GType.DOUBLE: g_value_init(_ret, Enum_GType.DOUBLE); g_value_set_float(_ret, cast(double) (_arg_value.toNumber())); return _ret; case Enum_GType.STRING: g_value_init(_ret, Enum_GType.STRING); g_value_set_string(_ret, std.string.toStringz(_arg_value.toString())); return _ret; case Enum_GType.OBJECT: // wrappers around structs.. char[] cname = std.string.replace(_arg_value.toObject().classname, ".", ""); g_value_init(_ret, g_type_from_name(std.string.toStringz(cname))); g_value_set_object(_ret, cast(void*) (_arg_value.toObject().getStruct())); return _ret; case Enum_GType.BOXED: // dobjects. return BoxedDobject_toGValue(_arg_value.toObject()); default: throw new Exception("unhandled type"); } return _ret; } void * dummy() { jscode: end jscode: g_value_get_boxed Wrapped_GValue* _arg_value = cast(Wrapped_GValue*) ((cast (Dobject)othis).getStruct()); Dobject _ret = cast(Dobject)g_value_get_boxed(_arg_value); if (!_ret) { ret.putVundefined(); } else { ret.putVobject(_ret); } jscode: end code: start code: end outFile: Value #class: Value #import: gobject.Value #prefix: g_ closeFile: Value #file: gobject-Varargs-Value-Collection.html #class: #prefix: #outFile: file: gobject-GParamSpec.html struct: GParamSpec class: ParamSpec prefix: g_param_spec_ import: glib.Str import: gobject.ParamSpec structWrap: GParamSpec* ParamSpec import: gobject.Value structWrap: GValue* Value #import: gobject.ParamSpecTypeInfo #structWrap: GParamSpecTypeInfo* ParamSpecTypeInfo #import: gobject.ParamSpecPool #structWrap: GParamSpecPool* ParamSpecPool #import: gobject.ParamSpec* #structWrap: GParamSpec** ParamSpec* import: glib.ListG structWrap: GList* ListG outFile: ParamSpec file: gobject-Signals.html class: Signals prefix: g_signal_ import: glib.Str import: gobject.Closure import: gobject.Type import: gobject.Value import: glib.Quark code: start public static uint connectData(void* instanc, char[] detailedSignal, GCallback cHandler, Object data, GClosureNotify destroyData, GConnectFlags connectFlags) { // gulong g_signal_connect_data (gpointer instance, const gchar *detailed_signal, GCallback c_handler, gpointer data, GClosureNotify destroy_data, GConnectFlags connect_flags); return g_signal_connect_data(instanc, Str.toStringz(detailedSignal), cHandler, cast(void*)data, destroyData, connectFlags); } code: end outFile: Signals file: gobject-Closures.html struct: GClosure class: Closure prefix: g_closure_ noprefix: g_cclosure import: gobject.ObjectG structWrap: GObject* ObjectG import: gobject.Closure structWrap: GClosure* Closure import: gobject.Value structWrap: GValue* Value import: glib.Source structWrap: GSource* Source outFile: Closure struct: GCClosure class: CClosure prefix: g_cclosure strictPrefix: Yes noprefix: g_closure_ noprefix: g_source_set_closure import: gobject.Closure structWrap: GClosure* Closure import: gobject.ObjectG structWrap: GObject* ObjectG import: gobject.Value structWrap: GValue* Value outFile: CClosure file: gobject-Value-arrays.html struct: GValueArray class: ValueArray prefix: g_value_array_ import: gobject.Value structWrap: GValue* Value import: gobject.ValueArray structWrap: GValueArray* ValueArray outFile: ValueArray