// This file was generated by the Gtk# code generator.
// Any changes made will be lost if regenerated.

namespace Gtk {

	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Runtime.InteropServices;
	using static GLib.AbiStructExtension;

#region Autogenerated code
	public partial class Style : GLib.Object {

		public Style (IntPtr raw) : base(raw) {}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_style_new();
		static d_gtk_style_new gtk_style_new = FuncLoader.LoadFunction<d_gtk_style_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_style_new"));

		[Obsolete]
		public Style () : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Style)) {
				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
				return;
			}
			Raw = gtk_style_new();
		}

		[GLib.Property ("context")]
		public Gtk.StyleContext Context {
			get {
				GLib.Value val = GetProperty ("context");
				Gtk.StyleContext ret = (Gtk.StyleContext) val;
				val.Dispose ();
				return ret;
			}
		}

		public Gdk.Color Black {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("black"));
					return Gdk.Color.New ((*raw_ptr));
				}
			}
		}

		public Gdk.Color White {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("white"));
					return Gdk.Color.New ((*raw_ptr));
				}
			}
		}

		public Pango.FontDescription FontDesc {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("font_desc"));
					return (*raw_ptr) == IntPtr.Zero ? null : (Pango.FontDescription) GLib.Opaque.GetOpaque ((*raw_ptr), typeof (Pango.FontDescription), false);
				}
			}
		}

		public int Xthickness {
			get {
				unsafe {
					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("xthickness"));
					return (*raw_ptr);
				}
			}
		}

		public int Ythickness {
			get {
				unsafe {
					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("ythickness"));
					return (*raw_ptr);
				}
			}
		}

		[GLib.Signal("unrealize")]
		public event System.EventHandler Unrealize {
			add {
				this.AddSignalHandler ("unrealize", value);
			}
			remove {
				this.RemoveSignalHandler ("unrealize", value);
			}
		}

		[GLib.Signal("realize")]
		public event System.EventHandler Realize {
			add {
				this.AddSignalHandler ("realize", value);
			}
			remove {
				this.RemoveSignalHandler ("realize", value);
			}
		}

		static RealizeNativeDelegate Realize_cb_delegate;
		static RealizeNativeDelegate RealizeVMCallback {
			get {
				if (Realize_cb_delegate == null)
					Realize_cb_delegate = new RealizeNativeDelegate (Realize_cb);
				return Realize_cb_delegate;
			}
		}

		static void OverrideRealize (GLib.GType gtype)
		{
			OverrideRealize (gtype, RealizeVMCallback);
		}

		static void OverrideRealize (GLib.GType gtype, RealizeNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("realize"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void RealizeNativeDelegate (IntPtr inst);

		static void Realize_cb (IntPtr inst)
		{
			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				__obj.OnRealize ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideRealize")]
		protected virtual void OnRealize ()
		{
			InternalRealize ();
		}

		private void InternalRealize ()
		{
			RealizeNativeDelegate unmanaged = class_abi.BaseOverride<RealizeNativeDelegate>(this.LookupGType(), "realize");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static UnrealizeNativeDelegate Unrealize_cb_delegate;
		static UnrealizeNativeDelegate UnrealizeVMCallback {
			get {
				if (Unrealize_cb_delegate == null)
					Unrealize_cb_delegate = new UnrealizeNativeDelegate (Unrealize_cb);
				return Unrealize_cb_delegate;
			}
		}

		static void OverrideUnrealize (GLib.GType gtype)
		{
			OverrideUnrealize (gtype, UnrealizeVMCallback);
		}

		static void OverrideUnrealize (GLib.GType gtype, UnrealizeNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("unrealize"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void UnrealizeNativeDelegate (IntPtr inst);

		static void Unrealize_cb (IntPtr inst)
		{
			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				__obj.OnUnrealize ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideUnrealize")]
		protected virtual void OnUnrealize ()
		{
			InternalUnrealize ();
		}

		private void InternalUnrealize ()
		{
			UnrealizeNativeDelegate unmanaged = class_abi.BaseOverride<UnrealizeNativeDelegate>(this.LookupGType(), "unrealize");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static CopyNativeDelegate Copy_cb_delegate;
		static CopyNativeDelegate CopyVMCallback {
			get {
				if (Copy_cb_delegate == null)
					Copy_cb_delegate = new CopyNativeDelegate (Copy_cb);
				return Copy_cb_delegate;
			}
		}

		static void OverrideCopy (GLib.GType gtype)
		{
			OverrideCopy (gtype, CopyVMCallback);
		}

		static void OverrideCopy (GLib.GType gtype, CopyNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("copy"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void CopyNativeDelegate (IntPtr inst, IntPtr src);

		static void Copy_cb (IntPtr inst, IntPtr src)
		{
			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				__obj.OnCopy (GLib.Object.GetObject(src) as Gtk.Style);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideCopy")]
		protected virtual void OnCopy (Gtk.Style src)
		{
			InternalCopy (src);
		}

		private void InternalCopy (Gtk.Style src)
		{
			CopyNativeDelegate unmanaged = class_abi.BaseOverride<CopyNativeDelegate>(this.LookupGType(), "copy");
			if (unmanaged == null) return;

			unmanaged (this.Handle, src == null ? IntPtr.Zero : src.Handle);
		}

		static CloneNativeDelegate Clone_cb_delegate;
		static CloneNativeDelegate CloneVMCallback {
			get {
				if (Clone_cb_delegate == null)
					Clone_cb_delegate = new CloneNativeDelegate (Clone_cb);
				return Clone_cb_delegate;
			}
		}

		static void OverrideClone (GLib.GType gtype)
		{
			OverrideClone (gtype, CloneVMCallback);
		}

		static void OverrideClone (GLib.GType gtype, CloneNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("clone"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr CloneNativeDelegate (IntPtr inst);

		static IntPtr Clone_cb (IntPtr inst)
		{
			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				Gtk.Style __result;
				__result = __obj.OnClone ();
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideClone")]
		protected virtual Gtk.Style OnClone ()
		{
			return InternalClone ();
		}

		private Gtk.Style InternalClone ()
		{
			CloneNativeDelegate unmanaged = class_abi.BaseOverride<CloneNativeDelegate>(this.LookupGType(), "clone");
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle);
			return GLib.Object.GetObject(__result) as Gtk.Style;
		}

		static InitFromRcNativeDelegate InitFromRc_cb_delegate;
		static InitFromRcNativeDelegate InitFromRcVMCallback {
			get {
				if (InitFromRc_cb_delegate == null)
					InitFromRc_cb_delegate = new InitFromRcNativeDelegate (InitFromRc_cb);
				return InitFromRc_cb_delegate;
			}
		}

		static void OverrideInitFromRc (GLib.GType gtype)
		{
			OverrideInitFromRc (gtype, InitFromRcVMCallback);
		}

		static void OverrideInitFromRc (GLib.GType gtype, InitFromRcNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("init_from_rc"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void InitFromRcNativeDelegate (IntPtr inst, IntPtr rc_style);

		static void InitFromRc_cb (IntPtr inst, IntPtr rc_style)
		{
			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				__obj.OnInitFromRc (GLib.Object.GetObject(rc_style) as Gtk.RcStyle);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideInitFromRc")]
		protected virtual void OnInitFromRc (Gtk.RcStyle rc_style)
		{
			InternalInitFromRc (rc_style);
		}

		private void InternalInitFromRc (Gtk.RcStyle rc_style)
		{
			InitFromRcNativeDelegate unmanaged = class_abi.BaseOverride<InitFromRcNativeDelegate>(this.LookupGType(), "init_from_rc");
			if (unmanaged == null) return;

			unmanaged (this.Handle, rc_style == null ? IntPtr.Zero : rc_style.Handle);
		}

		static SetBackgroundNativeDelegate SetBackground_cb_delegate;
		static SetBackgroundNativeDelegate SetBackgroundVMCallback {
			get {
				if (SetBackground_cb_delegate == null)
					SetBackground_cb_delegate = new SetBackgroundNativeDelegate (SetBackground_cb);
				return SetBackground_cb_delegate;
			}
		}

		static void OverrideSetBackground (GLib.GType gtype)
		{
			OverrideSetBackground (gtype, SetBackgroundVMCallback);
		}

		static void OverrideSetBackground (GLib.GType gtype, SetBackgroundNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_background"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetBackgroundNativeDelegate (IntPtr inst, IntPtr window, int state_type);

		static void SetBackground_cb (IntPtr inst, IntPtr window, int state_type)
		{
			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				__obj.OnSetBackground (GLib.Object.GetObject(window) as Gdk.Window, (Gtk.StateType) state_type);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideSetBackground")]
		protected virtual void OnSetBackground (Gdk.Window window, Gtk.StateType state_type)
		{
			InternalSetBackground (window, state_type);
		}

		private void InternalSetBackground (Gdk.Window window, Gtk.StateType state_type)
		{
			SetBackgroundNativeDelegate unmanaged = class_abi.BaseOverride<SetBackgroundNativeDelegate>(this.LookupGType(), "set_background");
			if (unmanaged == null) return;

			unmanaged (this.Handle, window == null ? IntPtr.Zero : window.Handle, (int) state_type);
		}

		static RenderIconNativeDelegate RenderIcon_cb_delegate;
		static RenderIconNativeDelegate RenderIconVMCallback {
			get {
				if (RenderIcon_cb_delegate == null)
					RenderIcon_cb_delegate = new RenderIconNativeDelegate (RenderIcon_cb);
				return RenderIcon_cb_delegate;
			}
		}

		static void OverrideRenderIcon (GLib.GType gtype)
		{
			OverrideRenderIcon (gtype, RenderIconVMCallback);
		}

		static void OverrideRenderIcon (GLib.GType gtype, RenderIconNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("render_icon"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr RenderIconNativeDelegate (IntPtr inst, IntPtr source, int direction, int state, int size, IntPtr widget, IntPtr detail);

		static IntPtr RenderIcon_cb (IntPtr inst, IntPtr source, int direction, int state, int size, IntPtr widget, IntPtr detail)
		{
			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				Gdk.Pixbuf __result;
				__result = __obj.OnRenderIcon (source == IntPtr.Zero ? null : (Gtk.IconSource) GLib.Opaque.GetOpaque (source, typeof (Gtk.IconSource), false), (Gtk.TextDirection) direction, (Gtk.StateType) state, (Gtk.IconSize) size, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail));
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideRenderIcon")]
		protected virtual Gdk.Pixbuf OnRenderIcon (Gtk.IconSource source, Gtk.TextDirection direction, Gtk.StateType state, Gtk.IconSize size, Gtk.Widget widget, string detail)
		{
			return InternalRenderIcon (source, direction, state, size, widget, detail);
		}

		private Gdk.Pixbuf InternalRenderIcon (Gtk.IconSource source, Gtk.TextDirection direction, Gtk.StateType state, Gtk.IconSize size, Gtk.Widget widget, string detail)
		{
			RenderIconNativeDelegate unmanaged = class_abi.BaseOverride<RenderIconNativeDelegate>(this.LookupGType(), "render_icon");
			if (unmanaged == null) return null;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			IntPtr __result = unmanaged (this.Handle, source == null ? IntPtr.Zero : source.Handle, (int) direction, (int) state, (int) size, widget == null ? IntPtr.Zero : widget.Handle, native_detail);
			GLib.Marshaller.Free (native_detail);
			return GLib.Object.GetObject(__result) as Gdk.Pixbuf;
		}

		static DrawHlineNativeDelegate DrawHline_cb_delegate;
		static DrawHlineNativeDelegate DrawHlineVMCallback {
			get {
				if (DrawHline_cb_delegate == null)
					DrawHline_cb_delegate = new DrawHlineNativeDelegate (DrawHline_cb);
				return DrawHline_cb_delegate;
			}
		}

		static void OverrideDrawHline (GLib.GType gtype)
		{
			OverrideDrawHline (gtype, DrawHlineVMCallback);
		}

		static void OverrideDrawHline (GLib.GType gtype, DrawHlineNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_hline"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawHlineNativeDelegate (IntPtr inst, IntPtr cr, int state_type, IntPtr widget, IntPtr detail, int x1, int x2, int y);

		static void DrawHline_cb (IntPtr inst, IntPtr cr, int state_type, IntPtr widget, IntPtr detail, int x1, int x2, int y)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawHline (mycr, (Gtk.StateType) state_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x1, x2, y);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawHline")]
		protected virtual void OnDrawHline (Cairo.Context cr, Gtk.StateType state_type, Gtk.Widget widget, string detail, int x1, int x2, int y)
		{
			InternalDrawHline (cr, state_type, widget, detail, x1, x2, y);
		}

		private void InternalDrawHline (Cairo.Context cr, Gtk.StateType state_type, Gtk.Widget widget, string detail, int x1, int x2, int y)
		{
			DrawHlineNativeDelegate unmanaged = class_abi.BaseOverride<DrawHlineNativeDelegate>(this.LookupGType(), "draw_hline");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x1, x2, y);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawVlineNativeDelegate DrawVline_cb_delegate;
		static DrawVlineNativeDelegate DrawVlineVMCallback {
			get {
				if (DrawVline_cb_delegate == null)
					DrawVline_cb_delegate = new DrawVlineNativeDelegate (DrawVline_cb);
				return DrawVline_cb_delegate;
			}
		}

		static void OverrideDrawVline (GLib.GType gtype)
		{
			OverrideDrawVline (gtype, DrawVlineVMCallback);
		}

		static void OverrideDrawVline (GLib.GType gtype, DrawVlineNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_vline"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawVlineNativeDelegate (IntPtr inst, IntPtr cr, int state_type, IntPtr widget, IntPtr detail, int y1_, int y2_, int x);

		static void DrawVline_cb (IntPtr inst, IntPtr cr, int state_type, IntPtr widget, IntPtr detail, int y1_, int y2_, int x)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawVline (mycr, (Gtk.StateType) state_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), y1_, y2_, x);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawVline")]
		protected virtual void OnDrawVline (Cairo.Context cr, Gtk.StateType state_type, Gtk.Widget widget, string detail, int y1_, int y2_, int x)
		{
			InternalDrawVline (cr, state_type, widget, detail, y1_, y2_, x);
		}

		private void InternalDrawVline (Cairo.Context cr, Gtk.StateType state_type, Gtk.Widget widget, string detail, int y1_, int y2_, int x)
		{
			DrawVlineNativeDelegate unmanaged = class_abi.BaseOverride<DrawVlineNativeDelegate>(this.LookupGType(), "draw_vline");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, y1_, y2_, x);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawShadowNativeDelegate DrawShadow_cb_delegate;
		static DrawShadowNativeDelegate DrawShadowVMCallback {
			get {
				if (DrawShadow_cb_delegate == null)
					DrawShadow_cb_delegate = new DrawShadowNativeDelegate (DrawShadow_cb);
				return DrawShadow_cb_delegate;
			}
		}

		static void OverrideDrawShadow (GLib.GType gtype)
		{
			OverrideDrawShadow (gtype, DrawShadowVMCallback);
		}

		static void OverrideDrawShadow (GLib.GType gtype, DrawShadowNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_shadow"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawShadowNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height);

		static void DrawShadow_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawShadow (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawShadow")]
		protected virtual void OnDrawShadow (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			InternalDrawShadow (cr, state_type, shadow_type, widget, detail, x, y, width, height);
		}

		private void InternalDrawShadow (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			DrawShadowNativeDelegate unmanaged = class_abi.BaseOverride<DrawShadowNativeDelegate>(this.LookupGType(), "draw_shadow");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawArrowNativeDelegate DrawArrow_cb_delegate;
		static DrawArrowNativeDelegate DrawArrowVMCallback {
			get {
				if (DrawArrow_cb_delegate == null)
					DrawArrow_cb_delegate = new DrawArrowNativeDelegate (DrawArrow_cb);
				return DrawArrow_cb_delegate;
			}
		}

		static void OverrideDrawArrow (GLib.GType gtype)
		{
			OverrideDrawArrow (gtype, DrawArrowVMCallback);
		}

		static void OverrideDrawArrow (GLib.GType gtype, DrawArrowNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_arrow"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawArrowNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int arrow_type, bool fill, int x, int y, int width, int height);

		static void DrawArrow_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int arrow_type, bool fill, int x, int y, int width, int height)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawArrow (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), (Gtk.ArrowType) arrow_type, fill, x, y, width, height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawArrow")]
		protected virtual void OnDrawArrow (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, Gtk.ArrowType arrow_type, bool fill, int x, int y, int width, int height)
		{
			InternalDrawArrow (cr, state_type, shadow_type, widget, detail, arrow_type, fill, x, y, width, height);
		}

		private void InternalDrawArrow (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, Gtk.ArrowType arrow_type, bool fill, int x, int y, int width, int height)
		{
			DrawArrowNativeDelegate unmanaged = class_abi.BaseOverride<DrawArrowNativeDelegate>(this.LookupGType(), "draw_arrow");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, (int) arrow_type, fill, x, y, width, height);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawDiamondNativeDelegate DrawDiamond_cb_delegate;
		static DrawDiamondNativeDelegate DrawDiamondVMCallback {
			get {
				if (DrawDiamond_cb_delegate == null)
					DrawDiamond_cb_delegate = new DrawDiamondNativeDelegate (DrawDiamond_cb);
				return DrawDiamond_cb_delegate;
			}
		}

		static void OverrideDrawDiamond (GLib.GType gtype)
		{
			OverrideDrawDiamond (gtype, DrawDiamondVMCallback);
		}

		static void OverrideDrawDiamond (GLib.GType gtype, DrawDiamondNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_diamond"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawDiamondNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height);

		static void DrawDiamond_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawDiamond (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawDiamond")]
		protected virtual void OnDrawDiamond (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			InternalDrawDiamond (cr, state_type, shadow_type, widget, detail, x, y, width, height);
		}

		private void InternalDrawDiamond (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			DrawDiamondNativeDelegate unmanaged = class_abi.BaseOverride<DrawDiamondNativeDelegate>(this.LookupGType(), "draw_diamond");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawBoxNativeDelegate DrawBox_cb_delegate;
		static DrawBoxNativeDelegate DrawBoxVMCallback {
			get {
				if (DrawBox_cb_delegate == null)
					DrawBox_cb_delegate = new DrawBoxNativeDelegate (DrawBox_cb);
				return DrawBox_cb_delegate;
			}
		}

		static void OverrideDrawBox (GLib.GType gtype)
		{
			OverrideDrawBox (gtype, DrawBoxVMCallback);
		}

		static void OverrideDrawBox (GLib.GType gtype, DrawBoxNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_box"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawBoxNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height);

		static void DrawBox_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawBox (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawBox")]
		protected virtual void OnDrawBox (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			InternalDrawBox (cr, state_type, shadow_type, widget, detail, x, y, width, height);
		}

		private void InternalDrawBox (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			DrawBoxNativeDelegate unmanaged = class_abi.BaseOverride<DrawBoxNativeDelegate>(this.LookupGType(), "draw_box");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawFlatBoxNativeDelegate DrawFlatBox_cb_delegate;
		static DrawFlatBoxNativeDelegate DrawFlatBoxVMCallback {
			get {
				if (DrawFlatBox_cb_delegate == null)
					DrawFlatBox_cb_delegate = new DrawFlatBoxNativeDelegate (DrawFlatBox_cb);
				return DrawFlatBox_cb_delegate;
			}
		}

		static void OverrideDrawFlatBox (GLib.GType gtype)
		{
			OverrideDrawFlatBox (gtype, DrawFlatBoxVMCallback);
		}

		static void OverrideDrawFlatBox (GLib.GType gtype, DrawFlatBoxNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_flat_box"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawFlatBoxNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height);

		static void DrawFlatBox_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawFlatBox (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawFlatBox")]
		protected virtual void OnDrawFlatBox (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			InternalDrawFlatBox (cr, state_type, shadow_type, widget, detail, x, y, width, height);
		}

		private void InternalDrawFlatBox (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			DrawFlatBoxNativeDelegate unmanaged = class_abi.BaseOverride<DrawFlatBoxNativeDelegate>(this.LookupGType(), "draw_flat_box");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawCheckNativeDelegate DrawCheck_cb_delegate;
		static DrawCheckNativeDelegate DrawCheckVMCallback {
			get {
				if (DrawCheck_cb_delegate == null)
					DrawCheck_cb_delegate = new DrawCheckNativeDelegate (DrawCheck_cb);
				return DrawCheck_cb_delegate;
			}
		}

		static void OverrideDrawCheck (GLib.GType gtype)
		{
			OverrideDrawCheck (gtype, DrawCheckVMCallback);
		}

		static void OverrideDrawCheck (GLib.GType gtype, DrawCheckNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_check"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawCheckNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height);

		static void DrawCheck_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawCheck (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawCheck")]
		protected virtual void OnDrawCheck (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			InternalDrawCheck (cr, state_type, shadow_type, widget, detail, x, y, width, height);
		}

		private void InternalDrawCheck (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			DrawCheckNativeDelegate unmanaged = class_abi.BaseOverride<DrawCheckNativeDelegate>(this.LookupGType(), "draw_check");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawOptionNativeDelegate DrawOption_cb_delegate;
		static DrawOptionNativeDelegate DrawOptionVMCallback {
			get {
				if (DrawOption_cb_delegate == null)
					DrawOption_cb_delegate = new DrawOptionNativeDelegate (DrawOption_cb);
				return DrawOption_cb_delegate;
			}
		}

		static void OverrideDrawOption (GLib.GType gtype)
		{
			OverrideDrawOption (gtype, DrawOptionVMCallback);
		}

		static void OverrideDrawOption (GLib.GType gtype, DrawOptionNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_option"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawOptionNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height);

		static void DrawOption_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawOption (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawOption")]
		protected virtual void OnDrawOption (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			InternalDrawOption (cr, state_type, shadow_type, widget, detail, x, y, width, height);
		}

		private void InternalDrawOption (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			DrawOptionNativeDelegate unmanaged = class_abi.BaseOverride<DrawOptionNativeDelegate>(this.LookupGType(), "draw_option");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawTabNativeDelegate DrawTab_cb_delegate;
		static DrawTabNativeDelegate DrawTabVMCallback {
			get {
				if (DrawTab_cb_delegate == null)
					DrawTab_cb_delegate = new DrawTabNativeDelegate (DrawTab_cb);
				return DrawTab_cb_delegate;
			}
		}

		static void OverrideDrawTab (GLib.GType gtype)
		{
			OverrideDrawTab (gtype, DrawTabVMCallback);
		}

		static void OverrideDrawTab (GLib.GType gtype, DrawTabNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_tab"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawTabNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height);

		static void DrawTab_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawTab (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawTab")]
		protected virtual void OnDrawTab (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			InternalDrawTab (cr, state_type, shadow_type, widget, detail, x, y, width, height);
		}

		private void InternalDrawTab (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			DrawTabNativeDelegate unmanaged = class_abi.BaseOverride<DrawTabNativeDelegate>(this.LookupGType(), "draw_tab");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawShadowGapNativeDelegate DrawShadowGap_cb_delegate;
		static DrawShadowGapNativeDelegate DrawShadowGapVMCallback {
			get {
				if (DrawShadowGap_cb_delegate == null)
					DrawShadowGap_cb_delegate = new DrawShadowGapNativeDelegate (DrawShadowGap_cb);
				return DrawShadowGap_cb_delegate;
			}
		}

		static void OverrideDrawShadowGap (GLib.GType gtype)
		{
			OverrideDrawShadowGap (gtype, DrawShadowGapVMCallback);
		}

		static void OverrideDrawShadowGap (GLib.GType gtype, DrawShadowGapNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_shadow_gap"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawShadowGapNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height, int gap_side, int gap_x, int gap_width);

		static void DrawShadowGap_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height, int gap_side, int gap_x, int gap_width)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawShadowGap (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height, (Gtk.PositionType) gap_side, gap_x, gap_width);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawShadowGap")]
		protected virtual void OnDrawShadowGap (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side, int gap_x, int gap_width)
		{
			InternalDrawShadowGap (cr, state_type, shadow_type, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
		}

		private void InternalDrawShadowGap (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side, int gap_x, int gap_width)
		{
			DrawShadowGapNativeDelegate unmanaged = class_abi.BaseOverride<DrawShadowGapNativeDelegate>(this.LookupGType(), "draw_shadow_gap");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height, (int) gap_side, gap_x, gap_width);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawBoxGapNativeDelegate DrawBoxGap_cb_delegate;
		static DrawBoxGapNativeDelegate DrawBoxGapVMCallback {
			get {
				if (DrawBoxGap_cb_delegate == null)
					DrawBoxGap_cb_delegate = new DrawBoxGapNativeDelegate (DrawBoxGap_cb);
				return DrawBoxGap_cb_delegate;
			}
		}

		static void OverrideDrawBoxGap (GLib.GType gtype)
		{
			OverrideDrawBoxGap (gtype, DrawBoxGapVMCallback);
		}

		static void OverrideDrawBoxGap (GLib.GType gtype, DrawBoxGapNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_box_gap"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawBoxGapNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height, int gap_side, int gap_x, int gap_width);

		static void DrawBoxGap_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height, int gap_side, int gap_x, int gap_width)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawBoxGap (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height, (Gtk.PositionType) gap_side, gap_x, gap_width);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawBoxGap")]
		protected virtual void OnDrawBoxGap (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side, int gap_x, int gap_width)
		{
			InternalDrawBoxGap (cr, state_type, shadow_type, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
		}

		private void InternalDrawBoxGap (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side, int gap_x, int gap_width)
		{
			DrawBoxGapNativeDelegate unmanaged = class_abi.BaseOverride<DrawBoxGapNativeDelegate>(this.LookupGType(), "draw_box_gap");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height, (int) gap_side, gap_x, gap_width);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawExtensionNativeDelegate DrawExtension_cb_delegate;
		static DrawExtensionNativeDelegate DrawExtensionVMCallback {
			get {
				if (DrawExtension_cb_delegate == null)
					DrawExtension_cb_delegate = new DrawExtensionNativeDelegate (DrawExtension_cb);
				return DrawExtension_cb_delegate;
			}
		}

		static void OverrideDrawExtension (GLib.GType gtype)
		{
			OverrideDrawExtension (gtype, DrawExtensionVMCallback);
		}

		static void OverrideDrawExtension (GLib.GType gtype, DrawExtensionNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_extension"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawExtensionNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height, int gap_side);

		static void DrawExtension_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height, int gap_side)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawExtension (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height, (Gtk.PositionType) gap_side);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawExtension")]
		protected virtual void OnDrawExtension (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side)
		{
			InternalDrawExtension (cr, state_type, shadow_type, widget, detail, x, y, width, height, gap_side);
		}

		private void InternalDrawExtension (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side)
		{
			DrawExtensionNativeDelegate unmanaged = class_abi.BaseOverride<DrawExtensionNativeDelegate>(this.LookupGType(), "draw_extension");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height, (int) gap_side);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawFocusNativeDelegate DrawFocus_cb_delegate;
		static DrawFocusNativeDelegate DrawFocusVMCallback {
			get {
				if (DrawFocus_cb_delegate == null)
					DrawFocus_cb_delegate = new DrawFocusNativeDelegate (DrawFocus_cb);
				return DrawFocus_cb_delegate;
			}
		}

		static void OverrideDrawFocus (GLib.GType gtype)
		{
			OverrideDrawFocus (gtype, DrawFocusVMCallback);
		}

		static void OverrideDrawFocus (GLib.GType gtype, DrawFocusNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_focus"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawFocusNativeDelegate (IntPtr inst, IntPtr cr, int state_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height);

		static void DrawFocus_cb (IntPtr inst, IntPtr cr, int state_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawFocus (mycr, (Gtk.StateType) state_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawFocus")]
		protected virtual void OnDrawFocus (Cairo.Context cr, Gtk.StateType state_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			InternalDrawFocus (cr, state_type, widget, detail, x, y, width, height);
		}

		private void InternalDrawFocus (Cairo.Context cr, Gtk.StateType state_type, Gtk.Widget widget, string detail, int x, int y, int width, int height)
		{
			DrawFocusNativeDelegate unmanaged = class_abi.BaseOverride<DrawFocusNativeDelegate>(this.LookupGType(), "draw_focus");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawSliderNativeDelegate DrawSlider_cb_delegate;
		static DrawSliderNativeDelegate DrawSliderVMCallback {
			get {
				if (DrawSlider_cb_delegate == null)
					DrawSlider_cb_delegate = new DrawSliderNativeDelegate (DrawSlider_cb);
				return DrawSlider_cb_delegate;
			}
		}

		static void OverrideDrawSlider (GLib.GType gtype)
		{
			OverrideDrawSlider (gtype, DrawSliderVMCallback);
		}

		static void OverrideDrawSlider (GLib.GType gtype, DrawSliderNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_slider"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawSliderNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height, int orientation);

		static void DrawSlider_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height, int orientation)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawSlider (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height, (Gtk.Orientation) orientation);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawSlider")]
		protected virtual void OnDrawSlider (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.Orientation orientation)
		{
			InternalDrawSlider (cr, state_type, shadow_type, widget, detail, x, y, width, height, orientation);
		}

		private void InternalDrawSlider (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.Orientation orientation)
		{
			DrawSliderNativeDelegate unmanaged = class_abi.BaseOverride<DrawSliderNativeDelegate>(this.LookupGType(), "draw_slider");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height, (int) orientation);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawHandleNativeDelegate DrawHandle_cb_delegate;
		static DrawHandleNativeDelegate DrawHandleVMCallback {
			get {
				if (DrawHandle_cb_delegate == null)
					DrawHandle_cb_delegate = new DrawHandleNativeDelegate (DrawHandle_cb);
				return DrawHandle_cb_delegate;
			}
		}

		static void OverrideDrawHandle (GLib.GType gtype)
		{
			OverrideDrawHandle (gtype, DrawHandleVMCallback);
		}

		static void OverrideDrawHandle (GLib.GType gtype, DrawHandleNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_handle"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawHandleNativeDelegate (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height, int orientation);

		static void DrawHandle_cb (IntPtr inst, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height, int orientation)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawHandle (mycr, (Gtk.StateType) state_type, (Gtk.ShadowType) shadow_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, width, height, (Gtk.Orientation) orientation);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawHandle")]
		protected virtual void OnDrawHandle (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.Orientation orientation)
		{
			InternalDrawHandle (cr, state_type, shadow_type, widget, detail, x, y, width, height, orientation);
		}

		private void InternalDrawHandle (Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.Orientation orientation)
		{
			DrawHandleNativeDelegate unmanaged = class_abi.BaseOverride<DrawHandleNativeDelegate>(this.LookupGType(), "draw_handle");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height, (int) orientation);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawExpanderNativeDelegate DrawExpander_cb_delegate;
		static DrawExpanderNativeDelegate DrawExpanderVMCallback {
			get {
				if (DrawExpander_cb_delegate == null)
					DrawExpander_cb_delegate = new DrawExpanderNativeDelegate (DrawExpander_cb);
				return DrawExpander_cb_delegate;
			}
		}

		static void OverrideDrawExpander (GLib.GType gtype)
		{
			OverrideDrawExpander (gtype, DrawExpanderVMCallback);
		}

		static void OverrideDrawExpander (GLib.GType gtype, DrawExpanderNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_expander"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawExpanderNativeDelegate (IntPtr inst, IntPtr cr, int state_type, IntPtr widget, IntPtr detail, int x, int y, int expander_style);

		static void DrawExpander_cb (IntPtr inst, IntPtr cr, int state_type, IntPtr widget, IntPtr detail, int x, int y, int expander_style)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawExpander (mycr, (Gtk.StateType) state_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, (Gtk.ExpanderStyle) expander_style);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawExpander")]
		protected virtual void OnDrawExpander (Cairo.Context cr, Gtk.StateType state_type, Gtk.Widget widget, string detail, int x, int y, Gtk.ExpanderStyle expander_style)
		{
			InternalDrawExpander (cr, state_type, widget, detail, x, y, expander_style);
		}

		private void InternalDrawExpander (Cairo.Context cr, Gtk.StateType state_type, Gtk.Widget widget, string detail, int x, int y, Gtk.ExpanderStyle expander_style)
		{
			DrawExpanderNativeDelegate unmanaged = class_abi.BaseOverride<DrawExpanderNativeDelegate>(this.LookupGType(), "draw_expander");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, (int) expander_style);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawLayoutNativeDelegate DrawLayout_cb_delegate;
		static DrawLayoutNativeDelegate DrawLayoutVMCallback {
			get {
				if (DrawLayout_cb_delegate == null)
					DrawLayout_cb_delegate = new DrawLayoutNativeDelegate (DrawLayout_cb);
				return DrawLayout_cb_delegate;
			}
		}

		static void OverrideDrawLayout (GLib.GType gtype)
		{
			OverrideDrawLayout (gtype, DrawLayoutVMCallback);
		}

		static void OverrideDrawLayout (GLib.GType gtype, DrawLayoutNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_layout"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawLayoutNativeDelegate (IntPtr inst, IntPtr cr, int state_type, bool use_text, IntPtr widget, IntPtr detail, int x, int y, IntPtr layout);

		static void DrawLayout_cb (IntPtr inst, IntPtr cr, int state_type, bool use_text, IntPtr widget, IntPtr detail, int x, int y, IntPtr layout)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawLayout (mycr, (Gtk.StateType) state_type, use_text, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), x, y, GLib.Object.GetObject(layout) as Pango.Layout);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawLayout")]
		protected virtual void OnDrawLayout (Cairo.Context cr, Gtk.StateType state_type, bool use_text, Gtk.Widget widget, string detail, int x, int y, Pango.Layout layout)
		{
			InternalDrawLayout (cr, state_type, use_text, widget, detail, x, y, layout);
		}

		private void InternalDrawLayout (Cairo.Context cr, Gtk.StateType state_type, bool use_text, Gtk.Widget widget, string detail, int x, int y, Pango.Layout layout)
		{
			DrawLayoutNativeDelegate unmanaged = class_abi.BaseOverride<DrawLayoutNativeDelegate>(this.LookupGType(), "draw_layout");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, use_text, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, layout == null ? IntPtr.Zero : layout.Handle);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawResizeGripNativeDelegate DrawResizeGrip_cb_delegate;
		static DrawResizeGripNativeDelegate DrawResizeGripVMCallback {
			get {
				if (DrawResizeGrip_cb_delegate == null)
					DrawResizeGrip_cb_delegate = new DrawResizeGripNativeDelegate (DrawResizeGrip_cb);
				return DrawResizeGrip_cb_delegate;
			}
		}

		static void OverrideDrawResizeGrip (GLib.GType gtype)
		{
			OverrideDrawResizeGrip (gtype, DrawResizeGripVMCallback);
		}

		static void OverrideDrawResizeGrip (GLib.GType gtype, DrawResizeGripNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_resize_grip"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawResizeGripNativeDelegate (IntPtr inst, IntPtr cr, int state_type, IntPtr widget, IntPtr detail, int edge, int x, int y, int width, int height);

		static void DrawResizeGrip_cb (IntPtr inst, IntPtr cr, int state_type, IntPtr widget, IntPtr detail, int edge, int x, int y, int width, int height)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawResizeGrip (mycr, (Gtk.StateType) state_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), (Gdk.WindowEdge) edge, x, y, width, height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawResizeGrip")]
		protected virtual void OnDrawResizeGrip (Cairo.Context cr, Gtk.StateType state_type, Gtk.Widget widget, string detail, Gdk.WindowEdge edge, int x, int y, int width, int height)
		{
			InternalDrawResizeGrip (cr, state_type, widget, detail, edge, x, y, width, height);
		}

		private void InternalDrawResizeGrip (Cairo.Context cr, Gtk.StateType state_type, Gtk.Widget widget, string detail, Gdk.WindowEdge edge, int x, int y, int width, int height)
		{
			DrawResizeGripNativeDelegate unmanaged = class_abi.BaseOverride<DrawResizeGripNativeDelegate>(this.LookupGType(), "draw_resize_grip");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, (int) edge, x, y, width, height);
			GLib.Marshaller.Free (native_detail);
		}

		static DrawSpinnerNativeDelegate DrawSpinner_cb_delegate;
		static DrawSpinnerNativeDelegate DrawSpinnerVMCallback {
			get {
				if (DrawSpinner_cb_delegate == null)
					DrawSpinner_cb_delegate = new DrawSpinnerNativeDelegate (DrawSpinner_cb);
				return DrawSpinner_cb_delegate;
			}
		}

		static void OverrideDrawSpinner (GLib.GType gtype)
		{
			OverrideDrawSpinner (gtype, DrawSpinnerVMCallback);
		}

		static void OverrideDrawSpinner (GLib.GType gtype, DrawSpinnerNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw_spinner"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawSpinnerNativeDelegate (IntPtr inst, IntPtr cr, int state_type, IntPtr widget, IntPtr detail, uint step, int x, int y, int width, int height);

		static void DrawSpinner_cb (IntPtr inst, IntPtr cr, int state_type, IntPtr widget, IntPtr detail, uint step, int x, int y, int width, int height)
		{
			Cairo.Context mycr = null;

			try {
				Style __obj = GLib.Object.GetObject (inst, false) as Style;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawSpinner (mycr, (Gtk.StateType) state_type, GLib.Object.GetObject(widget) as Gtk.Widget, GLib.Marshaller.Utf8PtrToString (detail), step, x, y, width, height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Style), ConnectionMethod="OverrideDrawSpinner")]
		protected virtual void OnDrawSpinner (Cairo.Context cr, Gtk.StateType state_type, Gtk.Widget widget, string detail, uint step, int x, int y, int width, int height)
		{
			InternalDrawSpinner (cr, state_type, widget, detail, step, x, y, width, height);
		}

		private void InternalDrawSpinner (Cairo.Context cr, Gtk.StateType state_type, Gtk.Widget widget, string detail, uint step, int x, int y, int width, int height)
		{
			DrawSpinnerNativeDelegate unmanaged = class_abi.BaseOverride<DrawSpinnerNativeDelegate>(this.LookupGType(), "draw_spinner");
			if (unmanaged == null) return;

			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, step, x, y, width, height);
			GLib.Marshaller.Free (native_detail);
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _class_abi = null;
		static public unsafe new GLib.AbiStruct class_abi {
			get {
				if (_class_abi == null)
					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("realize"
							, GLib.Object.class_abi.Fields
							, (uint) sizeof( IntPtr ) // realize
							, null
							, "unrealize"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("unrealize"
							, -1
							, (uint) sizeof( IntPtr ) // unrealize
							, "realize"
							, "copy"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("copy"
							, -1
							, (uint) sizeof( IntPtr ) // copy
							, "unrealize"
							, "clone"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("clone"
							, -1
							, (uint) sizeof( IntPtr ) // clone
							, "copy"
							, "init_from_rc"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("init_from_rc"
							, -1
							, (uint) sizeof( IntPtr ) // init_from_rc
							, "clone"
							, "set_background"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("set_background"
							, -1
							, (uint) sizeof( IntPtr ) // set_background
							, "init_from_rc"
							, "render_icon"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("render_icon"
							, -1
							, (uint) sizeof( IntPtr ) // render_icon
							, "set_background"
							, "draw_hline"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_hline"
							, -1
							, (uint) sizeof( IntPtr ) // draw_hline
							, "render_icon"
							, "draw_vline"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_vline"
							, -1
							, (uint) sizeof( IntPtr ) // draw_vline
							, "draw_hline"
							, "draw_shadow"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_shadow"
							, -1
							, (uint) sizeof( IntPtr ) // draw_shadow
							, "draw_vline"
							, "draw_arrow"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_arrow"
							, -1
							, (uint) sizeof( IntPtr ) // draw_arrow
							, "draw_shadow"
							, "draw_diamond"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_diamond"
							, -1
							, (uint) sizeof( IntPtr ) // draw_diamond
							, "draw_arrow"
							, "draw_box"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_box"
							, -1
							, (uint) sizeof( IntPtr ) // draw_box
							, "draw_diamond"
							, "draw_flat_box"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_flat_box"
							, -1
							, (uint) sizeof( IntPtr ) // draw_flat_box
							, "draw_box"
							, "draw_check"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_check"
							, -1
							, (uint) sizeof( IntPtr ) // draw_check
							, "draw_flat_box"
							, "draw_option"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_option"
							, -1
							, (uint) sizeof( IntPtr ) // draw_option
							, "draw_check"
							, "draw_tab"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_tab"
							, -1
							, (uint) sizeof( IntPtr ) // draw_tab
							, "draw_option"
							, "draw_shadow_gap"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_shadow_gap"
							, -1
							, (uint) sizeof( IntPtr ) // draw_shadow_gap
							, "draw_tab"
							, "draw_box_gap"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_box_gap"
							, -1
							, (uint) sizeof( IntPtr ) // draw_box_gap
							, "draw_shadow_gap"
							, "draw_extension"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_extension"
							, -1
							, (uint) sizeof( IntPtr ) // draw_extension
							, "draw_box_gap"
							, "draw_focus"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_focus"
							, -1
							, (uint) sizeof( IntPtr ) // draw_focus
							, "draw_extension"
							, "draw_slider"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_slider"
							, -1
							, (uint) sizeof( IntPtr ) // draw_slider
							, "draw_focus"
							, "draw_handle"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_handle"
							, -1
							, (uint) sizeof( IntPtr ) // draw_handle
							, "draw_slider"
							, "draw_expander"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_expander"
							, -1
							, (uint) sizeof( IntPtr ) // draw_expander
							, "draw_handle"
							, "draw_layout"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_layout"
							, -1
							, (uint) sizeof( IntPtr ) // draw_layout
							, "draw_expander"
							, "draw_resize_grip"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_resize_grip"
							, -1
							, (uint) sizeof( IntPtr ) // draw_resize_grip
							, "draw_layout"
							, "draw_spinner"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_spinner"
							, -1
							, (uint) sizeof( IntPtr ) // draw_spinner
							, "draw_resize_grip"
							, "_gtk_reserved1"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved1
							, "draw_spinner"
							, "_gtk_reserved2"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved2"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved2
							, "_gtk_reserved1"
							, "_gtk_reserved3"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved3"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved3
							, "_gtk_reserved2"
							, "_gtk_reserved4"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved4"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved4
							, "_gtk_reserved3"
							, "_gtk_reserved5"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved5"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved5
							, "_gtk_reserved4"
							, "_gtk_reserved6"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved6"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved6
							, "_gtk_reserved5"
							, "_gtk_reserved7"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved7"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved7
							, "_gtk_reserved6"
							, "_gtk_reserved8"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved8"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved8
							, "_gtk_reserved7"
							, "_gtk_reserved9"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved9"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved9
							, "_gtk_reserved8"
							, "_gtk_reserved10"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved10"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved10
							, "_gtk_reserved9"
							, "_gtk_reserved11"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved11"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved11
							, "_gtk_reserved10"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_style_attach(IntPtr raw, IntPtr window);
		static d_gtk_style_attach gtk_style_attach = FuncLoader.LoadFunction<d_gtk_style_attach>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_style_attach"));

		[Obsolete]
		public Gtk.Style Attach(Gdk.Window window) {
			IntPtr raw_ret = gtk_style_attach(Handle, window == null ? IntPtr.Zero : window.Handle);
			Gtk.Style ret = GLib.Object.GetObject(raw_ret) as Gtk.Style;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_style_copy(IntPtr raw);
		static d_gtk_style_copy gtk_style_copy = FuncLoader.LoadFunction<d_gtk_style_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_style_copy"));

		[Obsolete]
		public Gtk.Style Copy() {
			IntPtr raw_ret = gtk_style_copy(Handle);
			Gtk.Style ret = GLib.Object.GetObject(raw_ret, true) as Gtk.Style;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_style_detach(IntPtr raw);
		static d_gtk_style_detach gtk_style_detach = FuncLoader.LoadFunction<d_gtk_style_detach>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_style_detach"));

		[Obsolete]
		public void Detach() {
			gtk_style_detach(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_style_get_type();
		static d_gtk_style_get_type gtk_style_get_type = FuncLoader.LoadFunction<d_gtk_style_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_style_get_type"));

		[Obsolete]
		public static new GLib.GType GType { 
			get {
				IntPtr raw_ret = gtk_style_get_type();
				GLib.GType ret = new GLib.GType(raw_ret);
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_style_set_background(IntPtr raw, IntPtr window, int state_type);
		static d_gtk_style_set_background gtk_style_set_background = FuncLoader.LoadFunction<d_gtk_style_set_background>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_style_set_background"));

		[Obsolete]
		public void SetBackground(Gdk.Window window, Gtk.StateType state_type) {
			gtk_style_set_background(Handle, window == null ? IntPtr.Zero : window.Handle, (int) state_type);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_paint_box_gap(IntPtr style, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height, int gap_side, int gap_x, int gap_width);
		static d_gtk_paint_box_gap gtk_paint_box_gap = FuncLoader.LoadFunction<d_gtk_paint_box_gap>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_paint_box_gap"));

		[Obsolete]
		public static void PaintBoxGap(Gtk.Style style, Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side, int gap_x, int gap_width) {
			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			gtk_paint_box_gap(style == null ? IntPtr.Zero : style.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height, (int) gap_side, gap_x, gap_width);
			GLib.Marshaller.Free (native_detail);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_paint_shadow_gap(IntPtr style, IntPtr cr, int state_type, int shadow_type, IntPtr widget, IntPtr detail, int x, int y, int width, int height, int gap_side, int gap_x, int gap_width);
		static d_gtk_paint_shadow_gap gtk_paint_shadow_gap = FuncLoader.LoadFunction<d_gtk_paint_shadow_gap>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_paint_shadow_gap"));

		[Obsolete]
		public static void PaintShadowGap(Gtk.Style style, Cairo.Context cr, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side, int gap_x, int gap_width) {
			IntPtr native_detail = GLib.Marshaller.StringToPtrGStrdup (detail);
			gtk_paint_shadow_gap(style == null ? IntPtr.Zero : style.Handle, cr == null ? IntPtr.Zero : cr.Handle, (int) state_type, (int) shadow_type, widget == null ? IntPtr.Zero : widget.Handle, native_detail, x, y, width, height, (int) gap_side, gap_x, gap_width);
			GLib.Marshaller.Free (native_detail);
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _abi_info = null;
		static public unsafe new GLib.AbiStruct abi_info {
			get {
				if (_abi_info == null)
					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("fg"
							, GLib.Object.abi_info.Fields
							, (uint) Marshal.SizeOf<Gdk.Color>() * 5 // fg
							, null
							, "bg"
							, (long) Marshal.OffsetOf<GtkStyle_fgAlign>("fg")
							, 0
							),
						new GLib.AbiField("bg"
							, -1
							, (uint) Marshal.SizeOf<Gdk.Color>() * 5 // bg
							, "fg"
							, "light"
							, (long) Marshal.OffsetOf<GtkStyle_bgAlign>("bg")
							, 0
							),
						new GLib.AbiField("light"
							, -1
							, (uint) Marshal.SizeOf<Gdk.Color>() * 5 // light
							, "bg"
							, "dark"
							, (long) Marshal.OffsetOf<GtkStyle_lightAlign>("light")
							, 0
							),
						new GLib.AbiField("dark"
							, -1
							, (uint) Marshal.SizeOf<Gdk.Color>() * 5 // dark
							, "light"
							, "mid"
							, (long) Marshal.OffsetOf<GtkStyle_darkAlign>("dark")
							, 0
							),
						new GLib.AbiField("mid"
							, -1
							, (uint) Marshal.SizeOf<Gdk.Color>() * 5 // mid
							, "dark"
							, "text"
							, (long) Marshal.OffsetOf<GtkStyle_midAlign>("mid")
							, 0
							),
						new GLib.AbiField("text"
							, -1
							, (uint) Marshal.SizeOf<Gdk.Color>() * 5 // text
							, "mid"
							, "base"
							, (long) Marshal.OffsetOf<GtkStyle_textAlign>("text")
							, 0
							),
						new GLib.AbiField("base"
							, -1
							, (uint) Marshal.SizeOf<Gdk.Color>() * 5 // base
							, "text"
							, "text_aa"
							, (long) Marshal.OffsetOf<GtkStyle_baseAlign>("_base")
							, 0
							),
						new GLib.AbiField("text_aa"
							, -1
							, (uint) Marshal.SizeOf<Gdk.Color>() * 5 // text_aa
							, "base"
							, "black"
							, (long) Marshal.OffsetOf<GtkStyle_text_aaAlign>("text_aa")
							, 0
							),
						new GLib.AbiField("black"
							, -1
							, (uint) Marshal.SizeOf<Gdk.Color>() // black
							, "text_aa"
							, "white"
							, (long) Marshal.OffsetOf<GtkStyle_blackAlign>("black")
							, 0
							),
						new GLib.AbiField("white"
							, -1
							, (uint) Marshal.SizeOf<Gdk.Color>() // white
							, "black"
							, "font_desc"
							, (long) Marshal.OffsetOf<GtkStyle_whiteAlign>("white")
							, 0
							),
						new GLib.AbiField("font_desc"
							, -1
							, (uint) sizeof( IntPtr ) // font_desc
							, "white"
							, "xthickness"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("xthickness"
							, -1
							, (uint) sizeof( int ) // xthickness
							, "font_desc"
							, "ythickness"
							, (long) Marshal.OffsetOf<GtkStyle_xthicknessAlign>("xthickness")
							, 0
							),
						new GLib.AbiField("ythickness"
							, -1
							, (uint) sizeof( int ) // ythickness
							, "xthickness"
							, "background"
							, (long) Marshal.OffsetOf<GtkStyle_ythicknessAlign>("ythickness")
							, 0
							),
						new GLib.AbiField("background"
							, -1
							, (uint) sizeof( IntPtr ) * 5 // background
							, "ythickness"
							, "attach_count"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("attach_count"
							, -1
							, (uint) sizeof( int ) // attach_count
							, "background"
							, "visual"
							, (long) Marshal.OffsetOf<GtkStyle_attach_countAlign>("attach_count")
							, 0
							),
						new GLib.AbiField("visual"
							, -1
							, (uint) sizeof( IntPtr ) // visual
							, "attach_count"
							, "private_font_desc"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("private_font_desc"
							, -1
							, (uint) sizeof( IntPtr ) // private_font_desc
							, "visual"
							, "rc_style"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("rc_style"
							, -1
							, (uint) sizeof( IntPtr ) // rc_style
							, "private_font_desc"
							, "styles"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("styles"
							, -1
							, (uint) sizeof( IntPtr ) // styles
							, "rc_style"
							, "property_cache"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("property_cache"
							, -1
							, (uint) sizeof( IntPtr ) // property_cache
							, "styles"
							, "icon_factories"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("icon_factories"
							, -1
							, (uint) sizeof( IntPtr ) // icon_factories
							, "property_cache"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _abi_info;
			}
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_fgAlign
		{
			sbyte f1;
			[MarshalAs (UnmanagedType.ByValArray, SizeConst=5)]
			private Gdk.Color[] fg;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_bgAlign
		{
			sbyte f1;
			[MarshalAs (UnmanagedType.ByValArray, SizeConst=5)]
			private Gdk.Color[] bg;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_lightAlign
		{
			sbyte f1;
			[MarshalAs (UnmanagedType.ByValArray, SizeConst=5)]
			private Gdk.Color[] light;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_darkAlign
		{
			sbyte f1;
			[MarshalAs (UnmanagedType.ByValArray, SizeConst=5)]
			private Gdk.Color[] dark;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_midAlign
		{
			sbyte f1;
			[MarshalAs (UnmanagedType.ByValArray, SizeConst=5)]
			private Gdk.Color[] mid;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_textAlign
		{
			sbyte f1;
			[MarshalAs (UnmanagedType.ByValArray, SizeConst=5)]
			private Gdk.Color[] text;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_baseAlign
		{
			sbyte f1;
			[MarshalAs (UnmanagedType.ByValArray, SizeConst=5)]
			private Gdk.Color[] _base;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_text_aaAlign
		{
			sbyte f1;
			[MarshalAs (UnmanagedType.ByValArray, SizeConst=5)]
			private Gdk.Color[] text_aa;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_blackAlign
		{
			sbyte f1;
			private Gdk.Color black;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_whiteAlign
		{
			sbyte f1;
			private Gdk.Color white;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_xthicknessAlign
		{
			sbyte f1;
			private int xthickness;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_ythicknessAlign
		{
			sbyte f1;
			private int ythickness;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GtkStyle_attach_countAlign
		{
			sbyte f1;
			private int attach_count;
		}


		// End of the ABI representation.

#endregion
	}
}
