// 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 Calendar : Gtk.Widget {

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

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

		public Calendar () : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Calendar)) {
				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
				return;
			}
			Raw = gtk_calendar_new();
		}

		[GLib.Property ("year")]
		public int Year {
			get {
				GLib.Value val = GetProperty ("year");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("year", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("month")]
		public int Month {
			get {
				GLib.Value val = GetProperty ("month");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("month", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("day")]
		public int Day {
			get {
				GLib.Value val = GetProperty ("day");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("day", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("show-heading")]
		public bool ShowHeading {
			get {
				GLib.Value val = GetProperty ("show-heading");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("show-heading", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("show-day-names")]
		public bool ShowDayNames {
			get {
				GLib.Value val = GetProperty ("show-day-names");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("show-day-names", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("no-month-change")]
		public bool NoMonthChange {
			get {
				GLib.Value val = GetProperty ("no-month-change");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("no-month-change", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("show-week-numbers")]
		public bool ShowWeekNumbers {
			get {
				GLib.Value val = GetProperty ("show-week-numbers");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("show-week-numbers", val);
				val.Dispose ();
			}
		}

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

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

		[GLib.Property ("detail-width-chars")]
		public int DetailWidthChars {
			get  {
				int raw_ret = gtk_calendar_get_detail_width_chars(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_calendar_set_detail_width_chars(Handle, value);
			}
		}

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

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

		[GLib.Property ("detail-height-rows")]
		public int DetailHeightRows {
			get  {
				int raw_ret = gtk_calendar_get_detail_height_rows(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_calendar_set_detail_height_rows(Handle, value);
			}
		}

		[GLib.Property ("show-details")]
		public bool ShowDetails {
			get {
				GLib.Value val = GetProperty ("show-details");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("show-details", val);
				val.Dispose ();
			}
		}

		public int InnerBorder {
			get {
				var val = (int)StyleGetProperty("inner-border");
				return val;
			}
		}

		public int VerticalSeparation {
			get {
				var val = (int)StyleGetProperty("vertical-separation");
				return val;
			}
		}

		public int HorizontalSeparation {
			get {
				var val = (int)StyleGetProperty("horizontal-separation");
				return val;
			}
		}

		[GLib.Signal("day-selected-double-click")]
		public event System.EventHandler DaySelectedDoubleClick {
			add {
				this.AddSignalHandler ("day-selected-double-click", value);
			}
			remove {
				this.RemoveSignalHandler ("day-selected-double-click", value);
			}
		}

		[GLib.Signal("day-selected")]
		public event System.EventHandler DaySelected {
			add {
				this.AddSignalHandler ("day-selected", value);
			}
			remove {
				this.RemoveSignalHandler ("day-selected", value);
			}
		}

		[GLib.Signal("next-year")]
		public event System.EventHandler NextYear {
			add {
				this.AddSignalHandler ("next-year", value);
			}
			remove {
				this.RemoveSignalHandler ("next-year", value);
			}
		}

		[GLib.Signal("prev-year")]
		public event System.EventHandler PrevYear {
			add {
				this.AddSignalHandler ("prev-year", value);
			}
			remove {
				this.RemoveSignalHandler ("prev-year", value);
			}
		}

		[GLib.Signal("next-month")]
		public event System.EventHandler NextMonth {
			add {
				this.AddSignalHandler ("next-month", value);
			}
			remove {
				this.RemoveSignalHandler ("next-month", value);
			}
		}

		[GLib.Signal("month-changed")]
		public event System.EventHandler MonthChanged {
			add {
				this.AddSignalHandler ("month-changed", value);
			}
			remove {
				this.RemoveSignalHandler ("month-changed", value);
			}
		}

		[GLib.Signal("prev-month")]
		public event System.EventHandler PrevMonth {
			add {
				this.AddSignalHandler ("prev-month", value);
			}
			remove {
				this.RemoveSignalHandler ("prev-month", value);
			}
		}

		static MonthChangedNativeDelegate MonthChanged_cb_delegate;
		static MonthChangedNativeDelegate MonthChangedVMCallback {
			get {
				if (MonthChanged_cb_delegate == null)
					MonthChanged_cb_delegate = new MonthChangedNativeDelegate (MonthChanged_cb);
				return MonthChanged_cb_delegate;
			}
		}

		static void OverrideMonthChanged (GLib.GType gtype)
		{
			OverrideMonthChanged (gtype, MonthChangedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Calendar), ConnectionMethod="OverrideMonthChanged")]
		protected virtual void OnMonthChanged ()
		{
			InternalMonthChanged ();
		}

		private void InternalMonthChanged ()
		{
			MonthChangedNativeDelegate unmanaged = class_abi.BaseOverride<MonthChangedNativeDelegate>(this.LookupGType(), "month_changed");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static DaySelectedNativeDelegate DaySelected_cb_delegate;
		static DaySelectedNativeDelegate DaySelectedVMCallback {
			get {
				if (DaySelected_cb_delegate == null)
					DaySelected_cb_delegate = new DaySelectedNativeDelegate (DaySelected_cb);
				return DaySelected_cb_delegate;
			}
		}

		static void OverrideDaySelected (GLib.GType gtype)
		{
			OverrideDaySelected (gtype, DaySelectedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Calendar), ConnectionMethod="OverrideDaySelected")]
		protected virtual void OnDaySelected ()
		{
			InternalDaySelected ();
		}

		private void InternalDaySelected ()
		{
			DaySelectedNativeDelegate unmanaged = class_abi.BaseOverride<DaySelectedNativeDelegate>(this.LookupGType(), "day_selected");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static DaySelectedDoubleClickNativeDelegate DaySelectedDoubleClick_cb_delegate;
		static DaySelectedDoubleClickNativeDelegate DaySelectedDoubleClickVMCallback {
			get {
				if (DaySelectedDoubleClick_cb_delegate == null)
					DaySelectedDoubleClick_cb_delegate = new DaySelectedDoubleClickNativeDelegate (DaySelectedDoubleClick_cb);
				return DaySelectedDoubleClick_cb_delegate;
			}
		}

		static void OverrideDaySelectedDoubleClick (GLib.GType gtype)
		{
			OverrideDaySelectedDoubleClick (gtype, DaySelectedDoubleClickVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Calendar), ConnectionMethod="OverrideDaySelectedDoubleClick")]
		protected virtual void OnDaySelectedDoubleClick ()
		{
			InternalDaySelectedDoubleClick ();
		}

		private void InternalDaySelectedDoubleClick ()
		{
			DaySelectedDoubleClickNativeDelegate unmanaged = class_abi.BaseOverride<DaySelectedDoubleClickNativeDelegate>(this.LookupGType(), "day_selected_double_click");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static PrevMonthNativeDelegate PrevMonth_cb_delegate;
		static PrevMonthNativeDelegate PrevMonthVMCallback {
			get {
				if (PrevMonth_cb_delegate == null)
					PrevMonth_cb_delegate = new PrevMonthNativeDelegate (PrevMonth_cb);
				return PrevMonth_cb_delegate;
			}
		}

		static void OverridePrevMonth (GLib.GType gtype)
		{
			OverridePrevMonth (gtype, PrevMonthVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Calendar), ConnectionMethod="OverridePrevMonth")]
		protected virtual void OnPrevMonth ()
		{
			InternalPrevMonth ();
		}

		private void InternalPrevMonth ()
		{
			PrevMonthNativeDelegate unmanaged = class_abi.BaseOverride<PrevMonthNativeDelegate>(this.LookupGType(), "prev_month");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static NextMonthNativeDelegate NextMonth_cb_delegate;
		static NextMonthNativeDelegate NextMonthVMCallback {
			get {
				if (NextMonth_cb_delegate == null)
					NextMonth_cb_delegate = new NextMonthNativeDelegate (NextMonth_cb);
				return NextMonth_cb_delegate;
			}
		}

		static void OverrideNextMonth (GLib.GType gtype)
		{
			OverrideNextMonth (gtype, NextMonthVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Calendar), ConnectionMethod="OverrideNextMonth")]
		protected virtual void OnNextMonth ()
		{
			InternalNextMonth ();
		}

		private void InternalNextMonth ()
		{
			NextMonthNativeDelegate unmanaged = class_abi.BaseOverride<NextMonthNativeDelegate>(this.LookupGType(), "next_month");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static PrevYearNativeDelegate PrevYear_cb_delegate;
		static PrevYearNativeDelegate PrevYearVMCallback {
			get {
				if (PrevYear_cb_delegate == null)
					PrevYear_cb_delegate = new PrevYearNativeDelegate (PrevYear_cb);
				return PrevYear_cb_delegate;
			}
		}

		static void OverridePrevYear (GLib.GType gtype)
		{
			OverridePrevYear (gtype, PrevYearVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Calendar), ConnectionMethod="OverridePrevYear")]
		protected virtual void OnPrevYear ()
		{
			InternalPrevYear ();
		}

		private void InternalPrevYear ()
		{
			PrevYearNativeDelegate unmanaged = class_abi.BaseOverride<PrevYearNativeDelegate>(this.LookupGType(), "prev_year");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static NextYearNativeDelegate NextYear_cb_delegate;
		static NextYearNativeDelegate NextYearVMCallback {
			get {
				if (NextYear_cb_delegate == null)
					NextYear_cb_delegate = new NextYearNativeDelegate (NextYear_cb);
				return NextYear_cb_delegate;
			}
		}

		static void OverrideNextYear (GLib.GType gtype)
		{
			OverrideNextYear (gtype, NextYearVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Calendar), ConnectionMethod="OverrideNextYear")]
		protected virtual void OnNextYear ()
		{
			InternalNextYear ();
		}

		private void InternalNextYear ()
		{
			NextYearNativeDelegate unmanaged = class_abi.BaseOverride<NextYearNativeDelegate>(this.LookupGType(), "next_year");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}


		// 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("month_changed"
							, Gtk.Widget.class_abi.Fields
							, (uint) sizeof( IntPtr ) // month_changed
							, null
							, "day_selected"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("day_selected"
							, -1
							, (uint) sizeof( IntPtr ) // day_selected
							, "month_changed"
							, "day_selected_double_click"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("day_selected_double_click"
							, -1
							, (uint) sizeof( IntPtr ) // day_selected_double_click
							, "day_selected"
							, "prev_month"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("prev_month"
							, -1
							, (uint) sizeof( IntPtr ) // prev_month
							, "day_selected_double_click"
							, "next_month"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("next_month"
							, -1
							, (uint) sizeof( IntPtr ) // next_month
							, "prev_month"
							, "prev_year"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("prev_year"
							, -1
							, (uint) sizeof( IntPtr ) // prev_year
							, "next_month"
							, "next_year"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("next_year"
							, -1
							, (uint) sizeof( IntPtr ) // next_year
							, "prev_year"
							, "_gtk_reserved1"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved1
							, "next_year"
							, "_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"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

		public void ClearMarks() {
			gtk_calendar_clear_marks(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_calendar_get_date(IntPtr raw, out uint year, out uint month, out uint day);
		static d_gtk_calendar_get_date gtk_calendar_get_date = FuncLoader.LoadFunction<d_gtk_calendar_get_date>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_calendar_get_date"));

		public void GetDate(out uint year, out uint month, out uint day) {
			gtk_calendar_get_date(Handle, out year, out month, out day);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_calendar_get_day_is_marked(IntPtr raw, uint day);
		static d_gtk_calendar_get_day_is_marked gtk_calendar_get_day_is_marked = FuncLoader.LoadFunction<d_gtk_calendar_get_day_is_marked>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_calendar_get_day_is_marked"));

		public bool GetDayIsMarked(uint day) {
			bool raw_ret = gtk_calendar_get_day_is_marked(Handle, day);
			bool ret = raw_ret;
			return ret;
		}

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

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

		public Gtk.CalendarDisplayOptions DisplayOptions { 
			get {
				int raw_ret = gtk_calendar_get_display_options(Handle);
				Gtk.CalendarDisplayOptions ret = (Gtk.CalendarDisplayOptions) raw_ret;
				return ret;
			}
			set {
				gtk_calendar_set_display_options(Handle, (int) value);
			}
		}

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

		public static new GLib.GType GType { 
			get {
				IntPtr raw_ret = gtk_calendar_get_type();
				GLib.GType ret = new GLib.GType(raw_ret);
				return ret;
			}
		}

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

		public void MarkDay(uint day) {
			gtk_calendar_mark_day(Handle, day);
		}

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

		public void SelectDay(uint day) {
			gtk_calendar_select_day(Handle, day);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_calendar_select_month(IntPtr raw, uint month, uint year);
		static d_gtk_calendar_select_month gtk_calendar_select_month = FuncLoader.LoadFunction<d_gtk_calendar_select_month>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_calendar_select_month"));

		public void SelectMonth(uint month, uint year) {
			gtk_calendar_select_month(Handle, month, year);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_calendar_set_detail_func(IntPtr raw, GtkSharp.CalendarDetailFuncNative func, IntPtr data, GLib.DestroyNotify destroy);
		static d_gtk_calendar_set_detail_func gtk_calendar_set_detail_func = FuncLoader.LoadFunction<d_gtk_calendar_set_detail_func>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_calendar_set_detail_func"));

		public Gtk.CalendarDetailFunc DetailFunc { 
			set {
				GtkSharp.CalendarDetailFuncWrapper value_wrapper = new GtkSharp.CalendarDetailFuncWrapper (value);
				IntPtr data;
				GLib.DestroyNotify destroy;
				if (value == null) {
					data = IntPtr.Zero;
					destroy = null;
				} else {
					data = (IntPtr) GCHandle.Alloc (value_wrapper);
					destroy = GLib.DestroyHelper.NotifyHandler;
				}
				gtk_calendar_set_detail_func(Handle, value_wrapper.NativeDelegate, data, destroy);
			}
		}

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

		public void UnmarkDay(uint day) {
			gtk_calendar_unmark_day(Handle, day);
		}


		// 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("priv"
							, Gtk.Widget.abi_info.Fields
							, (uint) sizeof( IntPtr ) // priv
							, null
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}
