context: // 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;
  
  #region Autogenerated code
  	public partial class CellArea : GLib.InitiallyUnowned {
  
  		public CellArea (IntPtr raw) : base(raw) {}
  
  		protected CellArea() : base(IntPtr.Zero)
  		{
  			CreateNativeObject (new string [0], new GLib.Value [0]);
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gtk_cell_area_get_focus_cell(IntPtr raw);
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gtk_cell_area_set_focus_cell(IntPtr raw, IntPtr renderer);
  
  		[GLib.Property ("focus-cell")]
  		public Gtk.CellRenderer FocusCell {
  			get  {
  				IntPtr raw_ret = gtk_cell_area_get_focus_cell(Handle);
  				Gtk.CellRenderer ret = GLib.Object.GetObject(raw_ret) as Gtk.CellRenderer;
  				return ret;
  			}
  			set  {
  				gtk_cell_area_set_focus_cell(Handle, value == null ? IntPtr.Zero : value.Handle);
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gtk_cell_area_get_edited_cell(IntPtr raw);
  
  		[GLib.Property ("edited-cell")]
  		public Gtk.CellRenderer EditedCell {
  			get  {
  				IntPtr raw_ret = gtk_cell_area_get_edited_cell(Handle);
  				Gtk.CellRenderer ret = GLib.Object.GetObject(raw_ret) as Gtk.CellRenderer;
  				return ret;
  			}
  		}
  
  		[DllImport("libgtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gtk_cell_area_get_edit_widget(IntPtr raw);
  
  		[GLib.Property ("edit-widget")]
  		public Gtk.ICellEditable EditWidget {
  			get  {
  				IntPtr raw_ret = gtk_cell_area_get_edit_widget(Handle);
  				Gtk.ICellEditable ret = Gtk.CellEditableAdapter.GetObject (raw_ret, false);
  				return ret;
  			}
  		}
  
  		[GLib.Signal("remove-editable")]
  		public event Gtk.RemoveEditableHandler RemoveEditable {
  			add {
  				this.AddSignalHandler ("remove-editable", value, typeof (Gtk.RemoveEditableArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("remove-editable", value);
  			}
  		}
  
  		[GLib.Signal("focus-changed")]
  		public event Gtk.FocusChangedHandler FocusChanged {
  			add {
  				this.AddSignalHandler ("focus-changed", value, typeof (Gtk.FocusChangedArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("focus-changed", value);
  			}
  		}
  
  		[GLib.Signal("add-editable")]
  		public event Gtk.AddEditableHandler AddEditable {
  			add {
  				this.AddSignalHandler ("add-editable", value, typeof (Gtk.AddEditableArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("add-editable", value);
  			}
  		}
  
  		[GLib.Signal("apply-attributes")]
  		public event Gtk.AttributesAppliedHandler AttributesApplied {
  			add {
  				this.AddSignalHandler ("apply-attributes", value, typeof (Gtk.AttributesAppliedArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("apply-attributes", value);
  			}
  		}
  
  		static AddEditableNativeDelegate AddEditable_cb_delegate;
  		static AddEditableNativeDelegate AddEditableVMCallback {
  			get {
  				if (AddEditable_cb_delegate == null)
  					AddEditable_cb_delegate = new AddEditableNativeDelegate (AddEditable_cb);
  				return AddEditable_cb_delegate;
  			}
  		}
  
  		static void OverrideAddEditable (GLib.GType gtype)
  		{
  			OverrideAddEditable (gtype, AddEditableVMCallback);
  		}
  
  		static void OverrideAddEditable (GLib.GType gtype, AddEditableNativeDelegate callback)
  		{
  			OverrideVirtualMethod (gtype, "add-editable", callback);
  		}
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void AddEditableNativeDelegate (IntPtr inst, IntPtr p0, IntPtr p1, IntPtr p2, IntPtr p3);
  
  		static void AddEditable_cb (IntPtr inst, IntPtr p0, IntPtr p1, IntPtr p2, IntPtr p3)
  		{
  			try {
  				CellArea __obj = GLib.Object.GetObject (inst, false) as CellArea;
  				__obj.OnAddEditable (GLib.Object.GetObject(p0) as Gtk.CellRenderer, Gtk.CellEditableAdapter.GetObject (p1, false), (Gdk.Rectangle) Marshal.PtrToStructure (p2, typeof (Gdk.Rectangle)), GLib.Marshaller.PtrToStringGFree(p3));
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gtk.CellArea), ConnectionMethod="OverrideAddEditable")]
  		protected virtual void OnAddEditable (Gtk.CellRenderer p0, Gtk.ICellEditable p1, Gdk.Rectangle p2, string p3)
  		{
  			InternalAddEditable (p0, p1, p2, p3);
  		}
  
  		private void InternalAddEditable (Gtk.CellRenderer p0, Gtk.ICellEditable p1, Gdk.Rectangle p2, string p3)
  		{
  			GLib.Value ret = GLib.Value.Empty;
  			GLib.ValueArray inst_and_params = new GLib.ValueArray (5);
  			GLib.Value[] vals = new GLib.Value [5];
  			vals [0] = new GLib.Value (this);
  			inst_and_params.Append (vals [0]);
  			vals [1] = new GLib.Value (p0);
  			inst_and_params.Append (vals [1]);
  			vals [2] = new GLib.Value (p1);
  			inst_and_params.Append (vals [2]);
  			vals [3] = new GLib.Value (p2);
  			inst_and_params.Append (vals [3]);
  			vals [4] = new GLib.Value (p3);
  			inst_and_params.Append (vals [4]);
  			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
  			foreach (GLib.Value v in vals)
  				v.Dispose ();
  		}
  
  		static RemoveEditableNativeDelegate RemoveEditable_cb_delegate;
  		static RemoveEditableNativeDelegate RemoveEditableVMCallback {
  			get {
  				if (RemoveEditable_cb_delegate == null)
  					RemoveEditable_cb_delegate = new RemoveEditableNativeDelegate (RemoveEditable_cb);
  				return RemoveEditable_cb_delegate;
  			}
  		}
  
  		static void OverrideRemoveEditable (GLib.GType gtype)
  		{
  			OverrideRemoveEditable (gtype, RemoveEditableVMCallback);
  		}
  
  		static void OverrideRemoveEditable (GLib.GType gtype, RemoveEditableNativeDelegate callback)
  		{
  			OverrideVirtualMethod (gtype, "remove-editable", callback);
  		}
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void RemoveEditableNativeDelegate (IntPtr inst, IntPtr p0, IntPtr p1);
  
  		static void RemoveEditable_cb (IntPtr inst, IntPtr p0, IntPtr p1)
  		{
  			try {
  				CellArea __obj = GLib.Object.GetObject (inst, false) as CellArea;
  				__obj.OnRemoveEditable (GLib.Object.GetObject(p0) as Gtk.CellRenderer, Gtk.CellEditableAdapter.GetObject (p1, false));
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gtk.CellArea), ConnectionMethod="OverrideRemoveEditable")]
  		protected virtual void OnRemoveEditable (Gtk.CellRenderer p0, Gtk.ICellEditable p1)
  		{
  			InternalRemoveEditable (p0, p1);
  		}
  
  		private void InternalRemoveEditable (Gtk.CellRenderer p0, Gtk.ICellEditable p1)
  		{
  			GLib.Value ret = GLib.Value.Empty;
  			GLib.ValueArray inst_and_params = new GLib.ValueArray (3);
  			GLib.Value[] vals = new GLib.Value [3];
  			vals [0] = new GLib.Value (this);
  			inst_and_params.Append (vals [0]);
  			vals [1] = new GLib.Value (p0);
  			inst_and_params.Append (vals [1]);
  			vals [2] = new GLib.Value (p1);
  			inst_and_params.Append (vals [2]);
  			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
  			foreach (GLib.Value v in vals)
  				v.Dispose ();
  		}
  
  		static FocusChangedNativeDelegate FocusChanged_cb_delegate;
  		static FocusChangedNativeDelegate FocusChangedVMCallback {
  			get {
  				if (FocusChanged_cb_delegate == null)
  					FocusChanged_cb_delegate = new FocusChangedNativeDelegate (FocusChanged_cb);
  				return FocusChanged_cb_delegate;
  			}
  		}
  
  		static void OverrideFocusChanged (GLib.GType gtype)
  		{
  			OverrideFocusChanged (gtype, FocusChangedVMCallback);
  		}
  
  		static void OverrideFocusChanged (GLib.GType gtype, FocusChangedNativeDelegate callback)
  		{
  			OverrideVirtualMethod (gtype, "focus-changed", callback);
  		}
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void FocusChangedNativeDelegate (IntPtr inst, IntPtr p0, IntPtr p1);
  
  		static void FocusChanged_cb (IntPtr inst, IntPtr p0, IntPtr p1)
  		{
  			try {
  				CellArea __obj = GLib.Object.GetObject (inst, false) as CellArea;
  				__obj.OnFocusChanged (GLib.Object.GetObject(p0) as Gtk.CellRenderer, GLib.Marshaller.PtrToStringGFree(p1));
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gtk.CellArea), ConnectionMethod="OverrideFocusChanged")]
  		protected virtual void OnFocusChanged (Gtk.CellRenderer p0, string p1)
  		{
  			InternalFocusChanged (p0, p1);
  		}
  
  		private void InternalFocusChanged (Gtk.CellRenderer p0, string p1)
  		{
  			GLib.Value ret = GLib.Value.Empty;
  			GLib.ValueArray inst_and_params = new GLib.ValueArray (3);
  			GLib.Value[] vals = new GLib.Value [3];
  			vals [0] = new GLib.Value (this);
  			inst_and_params.Append (vals [0]);
  			vals [1] = new GLib.Value (p0);
  			inst_and_params.Append (vals [1]);
  			vals [2] = new GLib.Value (p1);
  			inst_and_params.Append (vals [2]);
  			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
  			foreach (GLib.Value v in vals)
  				v.Dispose ();
  		}
  
  		static AddNativeDelegate Add_cb_delegate;
  		static AddNativeDelegate AddVMCallback {
  			get {
  				if (Add_cb_delegate == null)
  					Add_cb_delegate = new AddNativeDelegate (Add_cb);
  				return Add_cb_delegate;
  			}
  		}
  
  		static void OverrideAdd (GLib.GType gtype)
  		{
  			OverrideAdd (gtype, AddVMCallback);
  		}
  
  		static void OverrideAdd (GLib.GType gtype, AddNativeDelegate callback)
  		{
  			GtkCellAreaClass class_iface = GetClassStruct (gtype, false);
  			class_iface.Add = callback;
  			OverrideClassStruct (gtype, class_iface);
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void AddNativeDelegate (IntPtr inst, IntPtr renderer);
  
  		static void Add_cb (IntPtr inst, IntPtr renderer)
  		{
  			try {
  				CellArea __obj = GLib.Object.GetObject (inst, false) as CellArea;
  				__obj.OnAdd (GLib.Object.GetObject(renderer) as Gtk.CellRenderer);
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gtk.CellArea), ConnectionMethod="OverrideAdd")]
  		protected virtual void OnAdd (Gtk.CellRenderer renderer)
  		{
  			InternalAdd (renderer);
  		}
  
  		private void InternalAdd (Gtk.CellRenderer renderer)
  		{
  			AddNativeDelegate unmanaged = GetClassStruct (this.LookupGType ().GetThresholdType (), true).Add;
  			if (unmanaged == null) return;
  
  			unmanaged (this.Handle, renderer == null ? IntPtr.Zero : renderer.Handle);
  		}
  
  		static RemoveNativeDelegate Remove_cb_delegate;
  		static RemoveNativeDelegate RemoveVMCallback {
  			get {
  				if (Remove_cb_delegate == null)
  					Remove_cb_delegate = new RemoveNativeDelegate (Remove_cb);
  				return Remove_cb_delegate;
  			}
  		}
  
  		static void OverrideRemove (GLib.GType gtype)
  		{
  			OverrideRemove (gtype, RemoveVMCallback);
  		}
  
  		static void OverrideRemove (GLib.GType gtype, RemoveNativeDelegate callback)
  		{
  			GtkCellAreaClass class_iface = GetClassStruct (gtype, false);
  			class_iface.Remove = callback;
  
gt: 			OverrideClassStruct (gtype, class_iface);