Fixtures: added UnmanagedFunctionPointer to whole delegate calls collection to prevent stack incosistence exception for x86 apllications on windows.

Source/Libs/AtkSharp/Global.cs

@@ -28,6 +28,7 @@ namespace Atk {
 
 	public partial class Global {
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_atk_add_global_event_listener(GLib.Signal.EmissionHookNative hook, IntPtr event_type);
         static d_atk_add_global_event_listener atk_add_global_event_listener = FuncLoader.LoadFunction<d_atk_add_global_event_listener>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Atk), "atk_add_global_event_listener"));
 
@@ -41,3 +42,4 @@ namespace Atk {
 		}
 	}
 }
+

Source/Libs/GLibSharp/Bytes.cs

@@ -27,6 +27,7 @@ namespace GLib {
 
 	public partial class Bytes : GLib.Opaque, IComparable<Bytes>, IEquatable<Bytes>
 	{
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_bytes_get_type();
 		static d_g_bytes_get_type g_bytes_get_type = FuncLoader.LoadFunction<d_g_bytes_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_bytes_get_type"));
 
@@ -39,7 +40,7 @@ namespace GLib {
 		}
 
 		public Bytes (IntPtr raw) : base (raw) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_bytes_new(byte [] data, UIntPtr size);
 		static d_g_bytes_new g_bytes_new = FuncLoader.LoadFunction<d_g_bytes_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_bytes_new"));
 
@@ -47,7 +48,7 @@ namespace GLib {
 		{
 			Raw = g_bytes_new (data, new UIntPtr ((ulong)data.Length));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_bytes_new_from_bytes(IntPtr raw, UIntPtr offset, UIntPtr length);
 		static d_g_bytes_new_from_bytes g_bytes_new_from_bytes = FuncLoader.LoadFunction<d_g_bytes_new_from_bytes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_bytes_new_from_bytes"));
 
@@ -55,7 +56,7 @@ namespace GLib {
 		{
 			Raw = g_bytes_new_from_bytes (bytes.Handle, new UIntPtr (offset), new UIntPtr (length));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_bytes_new_take(byte [] data, UIntPtr size);
 		static d_g_bytes_new_take g_bytes_new_take = FuncLoader.LoadFunction<d_g_bytes_new_take>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_bytes_new_take"));
 
@@ -63,7 +64,7 @@ namespace GLib {
 		{
 			return new Bytes (g_bytes_new_take (data, new UIntPtr ((ulong)data.Length)));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_bytes_new_static(byte [] data, UIntPtr size);
 		static d_g_bytes_new_static g_bytes_new_static = FuncLoader.LoadFunction<d_g_bytes_new_static>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_bytes_new_static"));
 
@@ -71,7 +72,7 @@ namespace GLib {
 		{
 			return new Bytes (g_bytes_new_static (data, new UIntPtr ((ulong)data.Length)));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_bytes_compare(IntPtr raw, IntPtr bytes);
 		static d_g_bytes_compare g_bytes_compare = FuncLoader.LoadFunction<d_g_bytes_compare>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_bytes_compare"));
 
@@ -79,7 +80,7 @@ namespace GLib {
 		{
 			return g_bytes_compare (Handle, bytes.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_bytes_equal(IntPtr raw, IntPtr bytes2);
 		static d_g_bytes_equal g_bytes_equal = FuncLoader.LoadFunction<d_g_bytes_equal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_bytes_equal"));
 
@@ -87,7 +88,7 @@ namespace GLib {
 		{
 			return g_bytes_equal (Handle, other.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate UIntPtr d_g_bytes_get_size(IntPtr raw);
 		static d_g_bytes_get_size g_bytes_get_size = FuncLoader.LoadFunction<d_g_bytes_get_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_bytes_get_size"));
 
@@ -96,7 +97,7 @@ namespace GLib {
 				return (ulong) g_bytes_get_size (Handle);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_bytes_hash(IntPtr raw);
 		static d_g_bytes_hash g_bytes_hash = FuncLoader.LoadFunction<d_g_bytes_hash>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_bytes_hash"));
 
@@ -104,7 +105,7 @@ namespace GLib {
 		{
 			return g_bytes_hash (Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_bytes_get_data(IntPtr raw, out UIntPtr size);
 		static d_g_bytes_get_data g_bytes_get_data = FuncLoader.LoadFunction<d_g_bytes_get_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_bytes_get_data"));
 
@@ -123,7 +124,7 @@ namespace GLib {
 				return bytes;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_bytes_ref(IntPtr raw);
 		static d_g_bytes_ref g_bytes_ref = FuncLoader.LoadFunction<d_g_bytes_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_bytes_ref"));
 
@@ -134,7 +135,7 @@ namespace GLib {
 				Owned = true;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_bytes_unref(IntPtr raw);
 		static d_g_bytes_unref g_bytes_unref = FuncLoader.LoadFunction<d_g_bytes_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_bytes_unref"));
 
@@ -171,3 +172,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GLibSharp/Cond.cs

@@ -15,42 +15,42 @@ namespace GLib {
 			int i1;
 			int i2;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_cond_broadcast(IntPtr raw);
 		static d_g_cond_broadcast g_cond_broadcast = FuncLoader.LoadFunction<d_g_cond_broadcast>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_cond_broadcast"));
 
 		public void Broadcast() {
 			g_cond_broadcast(Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_cond_clear(IntPtr raw);
 		static d_g_cond_clear g_cond_clear = FuncLoader.LoadFunction<d_g_cond_clear>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_cond_clear"));
 
 		public void Clear() {
 			g_cond_clear(Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_cond_init(IntPtr raw);
 		static d_g_cond_init g_cond_init = FuncLoader.LoadFunction<d_g_cond_init>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_cond_init"));
 
 		public void Init() {
 			g_cond_init(Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_cond_signal(IntPtr raw);
 		static d_g_cond_signal g_cond_signal = FuncLoader.LoadFunction<d_g_cond_signal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_cond_signal"));
 
 		public void Signal() {
 			g_cond_signal(Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_cond_wait(IntPtr raw, IntPtr mutex);
 		static d_g_cond_wait g_cond_wait = FuncLoader.LoadFunction<d_g_cond_wait>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_cond_wait"));
 
 		public void Wait(GLib.Mutex mutex) {
 			g_cond_wait(Handle, mutex == null ? IntPtr.Zero : mutex.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_cond_wait_until(IntPtr raw, IntPtr mutex, long end_time);
 		static d_g_cond_wait_until g_cond_wait_until = FuncLoader.LoadFunction<d_g_cond_wait_until>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_cond_wait_until"));
 
@@ -65,3 +65,4 @@ namespace GLib {
 #endregion
 	}
 }
+

Source/Libs/GLibSharp/Date.cs

@@ -10,7 +10,7 @@ namespace GLib {
 
 #region Autogenerated code
 	public partial class Date : GLib.Opaque {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_get_type();
 		static d_g_date_get_type g_date_get_type = FuncLoader.LoadFunction<d_g_date_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_type"));
 
@@ -21,42 +21,42 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_add_days(IntPtr raw, uint n_days);
 		static d_g_date_add_days g_date_add_days = FuncLoader.LoadFunction<d_g_date_add_days>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_add_days"));
 
 		public void AddDays(uint n_days) {
 			g_date_add_days(Handle, n_days);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_add_months(IntPtr raw, uint n_months);
 		static d_g_date_add_months g_date_add_months = FuncLoader.LoadFunction<d_g_date_add_months>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_add_months"));
 
 		public void AddMonths(uint n_months) {
 			g_date_add_months(Handle, n_months);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_add_years(IntPtr raw, uint n_years);
 		static d_g_date_add_years g_date_add_years = FuncLoader.LoadFunction<d_g_date_add_years>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_add_years"));
 
 		public void AddYears(uint n_years) {
 			g_date_add_years(Handle, n_years);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_clamp(IntPtr raw, IntPtr min_date, IntPtr max_date);
 		static d_g_date_clamp g_date_clamp = FuncLoader.LoadFunction<d_g_date_clamp>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_clamp"));
 
 		public void Clamp(GLib.Date min_date, GLib.Date max_date) {
 			g_date_clamp(Handle, min_date == null ? IntPtr.Zero : min_date.Handle, max_date == null ? IntPtr.Zero : max_date.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_clear(IntPtr raw, uint n_dates);
 		static d_g_date_clear g_date_clear = FuncLoader.LoadFunction<d_g_date_clear>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_clear"));
 
 		public void Clear(uint n_dates) {
 			g_date_clear(Handle, n_dates);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_compare(IntPtr raw, IntPtr rhs);
 		static d_g_date_compare g_date_compare = FuncLoader.LoadFunction<d_g_date_compare>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_compare"));
 
@@ -65,7 +65,7 @@ namespace GLib {
 			int ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_days_between(IntPtr raw, IntPtr date2);
 		static d_g_date_days_between g_date_days_between = FuncLoader.LoadFunction<d_g_date_days_between>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_days_between"));
 
@@ -74,10 +74,10 @@ namespace GLib {
 			int ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate byte d_g_date_get_day(IntPtr raw);
 		static d_g_date_get_day g_date_get_day = FuncLoader.LoadFunction<d_g_date_get_day>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_day"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_set_day(IntPtr raw, byte day);
 		static d_g_date_set_day g_date_set_day = FuncLoader.LoadFunction<d_g_date_set_day>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_set_day"));
 
@@ -91,7 +91,7 @@ namespace GLib {
 				g_date_set_day(Handle, value);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_date_get_day_of_year(IntPtr raw);
 		static d_g_date_get_day_of_year g_date_get_day_of_year = FuncLoader.LoadFunction<d_g_date_get_day_of_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_day_of_year"));
 
@@ -102,7 +102,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_date_get_iso8601_week_of_year(IntPtr raw);
 		static d_g_date_get_iso8601_week_of_year g_date_get_iso8601_week_of_year = FuncLoader.LoadFunction<d_g_date_get_iso8601_week_of_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_iso8601_week_of_year"));
 
@@ -113,10 +113,10 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_date_get_julian(IntPtr raw);
 		static d_g_date_get_julian g_date_get_julian = FuncLoader.LoadFunction<d_g_date_get_julian>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_julian"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_set_julian(IntPtr raw, uint julian_date);
 		static d_g_date_set_julian g_date_set_julian = FuncLoader.LoadFunction<d_g_date_set_julian>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_set_julian"));
 
@@ -130,7 +130,7 @@ namespace GLib {
 				g_date_set_julian(Handle, value);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_date_get_monday_week_of_year(IntPtr raw);
 		static d_g_date_get_monday_week_of_year g_date_get_monday_week_of_year = FuncLoader.LoadFunction<d_g_date_get_monday_week_of_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_monday_week_of_year"));
 
@@ -141,10 +141,10 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_get_month(IntPtr raw);
 		static d_g_date_get_month g_date_get_month = FuncLoader.LoadFunction<d_g_date_get_month>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_month"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_set_month(IntPtr raw, int month);
 		static d_g_date_set_month g_date_set_month = FuncLoader.LoadFunction<d_g_date_set_month>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_set_month"));
 
@@ -158,7 +158,7 @@ namespace GLib {
 				g_date_set_month(Handle, value);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_date_get_sunday_week_of_year(IntPtr raw);
 		static d_g_date_get_sunday_week_of_year g_date_get_sunday_week_of_year = FuncLoader.LoadFunction<d_g_date_get_sunday_week_of_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_sunday_week_of_year"));
 
@@ -169,7 +169,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_get_weekday(IntPtr raw);
 		static d_g_date_get_weekday g_date_get_weekday = FuncLoader.LoadFunction<d_g_date_get_weekday>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_weekday"));
 
@@ -180,10 +180,10 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate ushort d_g_date_get_year(IntPtr raw);
 		static d_g_date_get_year g_date_get_year = FuncLoader.LoadFunction<d_g_date_get_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_year"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_set_year(IntPtr raw, ushort year);
 		static d_g_date_set_year g_date_set_year = FuncLoader.LoadFunction<d_g_date_set_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_set_year"));
 
@@ -197,7 +197,7 @@ namespace GLib {
 				g_date_set_year(Handle, value);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_is_first_of_month(IntPtr raw);
 		static d_g_date_is_first_of_month g_date_is_first_of_month = FuncLoader.LoadFunction<d_g_date_is_first_of_month>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_is_first_of_month"));
 
@@ -208,7 +208,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_is_last_of_month(IntPtr raw);
 		static d_g_date_is_last_of_month g_date_is_last_of_month = FuncLoader.LoadFunction<d_g_date_is_last_of_month>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_is_last_of_month"));
 
@@ -219,21 +219,21 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_order(IntPtr raw, IntPtr date2);
 		static d_g_date_order g_date_order = FuncLoader.LoadFunction<d_g_date_order>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_order"));
 
 		public void Order(GLib.Date date2) {
 			g_date_order(Handle, date2 == null ? IntPtr.Zero : date2.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_set_dmy(IntPtr raw, byte day, int month, ushort y);
 		static d_g_date_set_dmy g_date_set_dmy = FuncLoader.LoadFunction<d_g_date_set_dmy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_set_dmy"));
 
 		public void SetDmy(byte day, int month, ushort y) {
 			g_date_set_dmy(Handle, day, month, y);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_set_parse(IntPtr raw, IntPtr str);
 		static d_g_date_set_parse g_date_set_parse = FuncLoader.LoadFunction<d_g_date_set_parse>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_set_parse"));
 
@@ -244,7 +244,7 @@ namespace GLib {
 				GLib.Marshaller.Free (native_value);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_set_time(IntPtr raw, int time_);
 		static d_g_date_set_time g_date_set_time = FuncLoader.LoadFunction<d_g_date_set_time>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_set_time"));
 
@@ -254,7 +254,7 @@ namespace GLib {
 				g_date_set_time(Handle, value);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_set_time_t(IntPtr raw, IntPtr timet);
 		static d_g_date_set_time_t g_date_set_time_t = FuncLoader.LoadFunction<d_g_date_set_time_t>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_set_time_t"));
 
@@ -263,7 +263,7 @@ namespace GLib {
 				g_date_set_time_t(Handle, new IntPtr (value));
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_set_time_val(IntPtr raw, IntPtr value);
 		static d_g_date_set_time_val g_date_set_time_val = FuncLoader.LoadFunction<d_g_date_set_time_val>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_set_time_val"));
 
@@ -275,35 +275,35 @@ namespace GLib {
 				Marshal.FreeHGlobal (native_value);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_subtract_days(IntPtr raw, uint n_days);
 		static d_g_date_subtract_days g_date_subtract_days = FuncLoader.LoadFunction<d_g_date_subtract_days>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_subtract_days"));
 
 		public void SubtractDays(uint n_days) {
 			g_date_subtract_days(Handle, n_days);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_subtract_months(IntPtr raw, uint n_months);
 		static d_g_date_subtract_months g_date_subtract_months = FuncLoader.LoadFunction<d_g_date_subtract_months>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_subtract_months"));
 
 		public void SubtractMonths(uint n_months) {
 			g_date_subtract_months(Handle, n_months);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_subtract_years(IntPtr raw, uint n_years);
 		static d_g_date_subtract_years g_date_subtract_years = FuncLoader.LoadFunction<d_g_date_subtract_years>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_subtract_years"));
 
 		public void SubtractYears(uint n_years) {
 			g_date_subtract_years(Handle, n_years);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_to_struct_tm(IntPtr raw, IntPtr tm);
 		static d_g_date_to_struct_tm g_date_to_struct_tm = FuncLoader.LoadFunction<d_g_date_to_struct_tm>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_to_struct_tm"));
 
 		public void ToStructTm(IntPtr tm) {
 			g_date_to_struct_tm(Handle, tm);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_valid(IntPtr raw);
 		static d_g_date_valid g_date_valid = FuncLoader.LoadFunction<d_g_date_valid>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_valid"));
 
@@ -312,7 +312,7 @@ namespace GLib {
 			bool ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate byte d_g_date_get_days_in_month(int month, ushort year);
 		static d_g_date_get_days_in_month g_date_get_days_in_month = FuncLoader.LoadFunction<d_g_date_get_days_in_month>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_days_in_month"));
 
@@ -321,7 +321,7 @@ namespace GLib {
 			byte ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate byte d_g_date_get_monday_weeks_in_year(ushort year);
 		static d_g_date_get_monday_weeks_in_year g_date_get_monday_weeks_in_year = FuncLoader.LoadFunction<d_g_date_get_monday_weeks_in_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_monday_weeks_in_year"));
 
@@ -330,7 +330,7 @@ namespace GLib {
 			byte ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate byte d_g_date_get_sunday_weeks_in_year(ushort year);
 		static d_g_date_get_sunday_weeks_in_year g_date_get_sunday_weeks_in_year = FuncLoader.LoadFunction<d_g_date_get_sunday_weeks_in_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_get_sunday_weeks_in_year"));
 
@@ -339,7 +339,7 @@ namespace GLib {
 			byte ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_is_leap_year(ushort year);
 		static d_g_date_is_leap_year g_date_is_leap_year = FuncLoader.LoadFunction<d_g_date_is_leap_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_is_leap_year"));
 
@@ -348,7 +348,7 @@ namespace GLib {
 			bool ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate UIntPtr d_g_date_strftime(IntPtr s, UIntPtr slen, IntPtr format, IntPtr date);
 		static d_g_date_strftime g_date_strftime = FuncLoader.LoadFunction<d_g_date_strftime>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_strftime"));
 
@@ -361,7 +361,7 @@ namespace GLib {
 			GLib.Marshaller.Free (native_format);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_valid_day(byte day);
 		static d_g_date_valid_day g_date_valid_day = FuncLoader.LoadFunction<d_g_date_valid_day>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_valid_day"));
 
@@ -370,7 +370,7 @@ namespace GLib {
 			bool ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_valid_dmy(byte day, int month, ushort year);
 		static d_g_date_valid_dmy g_date_valid_dmy = FuncLoader.LoadFunction<d_g_date_valid_dmy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_valid_dmy"));
 
@@ -379,7 +379,7 @@ namespace GLib {
 			bool ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_valid_julian(uint julian_date);
 		static d_g_date_valid_julian g_date_valid_julian = FuncLoader.LoadFunction<d_g_date_valid_julian>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_valid_julian"));
 
@@ -388,7 +388,7 @@ namespace GLib {
 			bool ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_valid_month(int month);
 		static d_g_date_valid_month g_date_valid_month = FuncLoader.LoadFunction<d_g_date_valid_month>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_valid_month"));
 
@@ -397,7 +397,7 @@ namespace GLib {
 			bool ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_valid_weekday(int weekday);
 		static d_g_date_valid_weekday g_date_valid_weekday = FuncLoader.LoadFunction<d_g_date_valid_weekday>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_valid_weekday"));
 
@@ -406,7 +406,7 @@ namespace GLib {
 			bool ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_valid_year(ushort year);
 		static d_g_date_valid_year g_date_valid_year = FuncLoader.LoadFunction<d_g_date_valid_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_valid_year"));
 
@@ -417,7 +417,7 @@ namespace GLib {
 		}
 
 		public Date(IntPtr raw) : base(raw) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_new();
 		static d_g_date_new g_date_new = FuncLoader.LoadFunction<d_g_date_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_new"));
 
@@ -425,7 +425,7 @@ namespace GLib {
 		{
 			Raw = g_date_new();
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_new_dmy(byte day, int month, ushort year);
 		static d_g_date_new_dmy g_date_new_dmy = FuncLoader.LoadFunction<d_g_date_new_dmy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_new_dmy"));
 
@@ -433,7 +433,7 @@ namespace GLib {
 		{
 			Raw = g_date_new_dmy(day, month, year);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_new_julian(uint julian_day);
 		static d_g_date_new_julian g_date_new_julian = FuncLoader.LoadFunction<d_g_date_new_julian>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_new_julian"));
 
@@ -441,7 +441,7 @@ namespace GLib {
 		{
 			Raw = g_date_new_julian(julian_day);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_free(IntPtr raw);
 		static d_g_date_free g_date_free = FuncLoader.LoadFunction<d_g_date_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_free"));
 
@@ -476,3 +476,4 @@ namespace GLib {
 #endregion
 	}
 }
+

Source/Libs/GLibSharp/DateTime.cs

@@ -10,7 +10,7 @@ namespace GLib {
 
 #region Autogenerated code
 	public partial class DateTime : GLib.Opaque {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_get_type();
 		static d_g_date_time_get_type g_date_time_get_type = FuncLoader.LoadFunction<d_g_date_time_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_type"));
 
@@ -21,7 +21,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_add(IntPtr raw, long timespan);
 		static d_g_date_time_add g_date_time_add = FuncLoader.LoadFunction<d_g_date_time_add>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_add"));
 
@@ -30,7 +30,7 @@ namespace GLib {
 			GLib.DateTime ret = raw_ret == IntPtr.Zero ? null : (GLib.DateTime) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.DateTime), true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_add_days(IntPtr raw, int days);
 		static d_g_date_time_add_days g_date_time_add_days = FuncLoader.LoadFunction<d_g_date_time_add_days>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_add_days"));
 
@@ -39,7 +39,7 @@ namespace GLib {
 			GLib.DateTime ret = raw_ret == IntPtr.Zero ? null : (GLib.DateTime) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.DateTime), true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_add_full(IntPtr raw, int years, int months, int days, int hours, int minutes, double seconds);
 		static d_g_date_time_add_full g_date_time_add_full = FuncLoader.LoadFunction<d_g_date_time_add_full>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_add_full"));
 
@@ -48,7 +48,7 @@ namespace GLib {
 			GLib.DateTime ret = raw_ret == IntPtr.Zero ? null : (GLib.DateTime) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.DateTime), true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_add_hours(IntPtr raw, int hours);
 		static d_g_date_time_add_hours g_date_time_add_hours = FuncLoader.LoadFunction<d_g_date_time_add_hours>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_add_hours"));
 
@@ -57,7 +57,7 @@ namespace GLib {
 			GLib.DateTime ret = raw_ret == IntPtr.Zero ? null : (GLib.DateTime) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.DateTime), true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_add_minutes(IntPtr raw, int minutes);
 		static d_g_date_time_add_minutes g_date_time_add_minutes = FuncLoader.LoadFunction<d_g_date_time_add_minutes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_add_minutes"));
 
@@ -66,7 +66,7 @@ namespace GLib {
 			GLib.DateTime ret = raw_ret == IntPtr.Zero ? null : (GLib.DateTime) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.DateTime), true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_add_months(IntPtr raw, int months);
 		static d_g_date_time_add_months g_date_time_add_months = FuncLoader.LoadFunction<d_g_date_time_add_months>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_add_months"));
 
@@ -75,7 +75,7 @@ namespace GLib {
 			GLib.DateTime ret = raw_ret == IntPtr.Zero ? null : (GLib.DateTime) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.DateTime), true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_add_seconds(IntPtr raw, double seconds);
 		static d_g_date_time_add_seconds g_date_time_add_seconds = FuncLoader.LoadFunction<d_g_date_time_add_seconds>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_add_seconds"));
 
@@ -84,7 +84,7 @@ namespace GLib {
 			GLib.DateTime ret = raw_ret == IntPtr.Zero ? null : (GLib.DateTime) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.DateTime), true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_add_weeks(IntPtr raw, int weeks);
 		static d_g_date_time_add_weeks g_date_time_add_weeks = FuncLoader.LoadFunction<d_g_date_time_add_weeks>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_add_weeks"));
 
@@ -93,7 +93,7 @@ namespace GLib {
 			GLib.DateTime ret = raw_ret == IntPtr.Zero ? null : (GLib.DateTime) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.DateTime), true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_add_years(IntPtr raw, int years);
 		static d_g_date_time_add_years g_date_time_add_years = FuncLoader.LoadFunction<d_g_date_time_add_years>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_add_years"));
 
@@ -102,7 +102,7 @@ namespace GLib {
 			GLib.DateTime ret = raw_ret == IntPtr.Zero ? null : (GLib.DateTime) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.DateTime), true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate long d_g_date_time_difference(IntPtr raw, IntPtr begin);
 		static d_g_date_time_difference g_date_time_difference = FuncLoader.LoadFunction<d_g_date_time_difference>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_difference"));
 
@@ -111,7 +111,7 @@ namespace GLib {
 			long ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_format(IntPtr raw, IntPtr format);
 		static d_g_date_time_format g_date_time_format = FuncLoader.LoadFunction<d_g_date_time_format>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_format"));
 
@@ -122,7 +122,7 @@ namespace GLib {
 			GLib.Marshaller.Free (native_format);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_time_get_day_of_month(IntPtr raw);
 		static d_g_date_time_get_day_of_month g_date_time_get_day_of_month = FuncLoader.LoadFunction<d_g_date_time_get_day_of_month>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_day_of_month"));
 
@@ -133,7 +133,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_time_get_day_of_week(IntPtr raw);
 		static d_g_date_time_get_day_of_week g_date_time_get_day_of_week = FuncLoader.LoadFunction<d_g_date_time_get_day_of_week>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_day_of_week"));
 
@@ -144,7 +144,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_time_get_day_of_year(IntPtr raw);
 		static d_g_date_time_get_day_of_year g_date_time_get_day_of_year = FuncLoader.LoadFunction<d_g_date_time_get_day_of_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_day_of_year"));
 
@@ -155,7 +155,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_time_get_hour(IntPtr raw);
 		static d_g_date_time_get_hour g_date_time_get_hour = FuncLoader.LoadFunction<d_g_date_time_get_hour>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_hour"));
 
@@ -166,7 +166,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_time_get_microsecond(IntPtr raw);
 		static d_g_date_time_get_microsecond g_date_time_get_microsecond = FuncLoader.LoadFunction<d_g_date_time_get_microsecond>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_microsecond"));
 
@@ -177,7 +177,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_time_get_minute(IntPtr raw);
 		static d_g_date_time_get_minute g_date_time_get_minute = FuncLoader.LoadFunction<d_g_date_time_get_minute>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_minute"));
 
@@ -188,7 +188,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_time_get_month(IntPtr raw);
 		static d_g_date_time_get_month g_date_time_get_month = FuncLoader.LoadFunction<d_g_date_time_get_month>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_month"));
 
@@ -199,7 +199,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_time_get_second(IntPtr raw);
 		static d_g_date_time_get_second g_date_time_get_second = FuncLoader.LoadFunction<d_g_date_time_get_second>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_second"));
 
@@ -210,7 +210,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate double d_g_date_time_get_seconds(IntPtr raw);
 		static d_g_date_time_get_seconds g_date_time_get_seconds = FuncLoader.LoadFunction<d_g_date_time_get_seconds>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_seconds"));
 
@@ -221,7 +221,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_get_timezone_abbreviation(IntPtr raw);
 		static d_g_date_time_get_timezone_abbreviation g_date_time_get_timezone_abbreviation = FuncLoader.LoadFunction<d_g_date_time_get_timezone_abbreviation>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_timezone_abbreviation"));
 
@@ -232,7 +232,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate long d_g_date_time_get_utc_offset(IntPtr raw);
 		static d_g_date_time_get_utc_offset g_date_time_get_utc_offset = FuncLoader.LoadFunction<d_g_date_time_get_utc_offset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_utc_offset"));
 
@@ -243,7 +243,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_time_get_week_numbering_year(IntPtr raw);
 		static d_g_date_time_get_week_numbering_year g_date_time_get_week_numbering_year = FuncLoader.LoadFunction<d_g_date_time_get_week_numbering_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_week_numbering_year"));
 
@@ -254,7 +254,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_time_get_week_of_year(IntPtr raw);
 		static d_g_date_time_get_week_of_year g_date_time_get_week_of_year = FuncLoader.LoadFunction<d_g_date_time_get_week_of_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_week_of_year"));
 
@@ -265,7 +265,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_time_get_year(IntPtr raw);
 		static d_g_date_time_get_year g_date_time_get_year = FuncLoader.LoadFunction<d_g_date_time_get_year>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_year"));
 
@@ -276,14 +276,14 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_time_get_ymd(IntPtr raw, out int year, out int month, out int day);
 		static d_g_date_time_get_ymd g_date_time_get_ymd = FuncLoader.LoadFunction<d_g_date_time_get_ymd>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_get_ymd"));
 
 		public void GetYmd(out int year, out int month, out int day) {
 			g_date_time_get_ymd(Handle, out year, out month, out day);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_time_is_daylight_savings(IntPtr raw);
 		static d_g_date_time_is_daylight_savings g_date_time_is_daylight_savings = FuncLoader.LoadFunction<d_g_date_time_is_daylight_savings>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_is_daylight_savings"));
 
@@ -294,7 +294,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_to_local(IntPtr raw);
 		static d_g_date_time_to_local g_date_time_to_local = FuncLoader.LoadFunction<d_g_date_time_to_local>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_to_local"));
 
@@ -303,7 +303,7 @@ namespace GLib {
 			GLib.DateTime ret = raw_ret == IntPtr.Zero ? null : (GLib.DateTime) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.DateTime), true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_time_to_timeval(IntPtr raw, IntPtr tv);
 		static d_g_date_time_to_timeval g_date_time_to_timeval = FuncLoader.LoadFunction<d_g_date_time_to_timeval>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_to_timeval"));
 
@@ -315,7 +315,7 @@ namespace GLib {
 			Marshal.FreeHGlobal (native_tv);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_to_timezone(IntPtr raw, IntPtr tz);
 		static d_g_date_time_to_timezone g_date_time_to_timezone = FuncLoader.LoadFunction<d_g_date_time_to_timezone>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_to_timezone"));
 
@@ -324,7 +324,7 @@ namespace GLib {
 			GLib.DateTime ret = raw_ret == IntPtr.Zero ? null : (GLib.DateTime) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.DateTime), true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate long d_g_date_time_to_unix(IntPtr raw);
 		static d_g_date_time_to_unix g_date_time_to_unix = FuncLoader.LoadFunction<d_g_date_time_to_unix>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_to_unix"));
 
@@ -333,7 +333,7 @@ namespace GLib {
 			long ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_to_utc(IntPtr raw);
 		static d_g_date_time_to_utc g_date_time_to_utc = FuncLoader.LoadFunction<d_g_date_time_to_utc>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_to_utc"));
 
@@ -342,7 +342,7 @@ namespace GLib {
 			GLib.DateTime ret = raw_ret == IntPtr.Zero ? null : (GLib.DateTime) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.DateTime), true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_date_time_compare(IntPtr dt1, IntPtr dt2);
 		static d_g_date_time_compare g_date_time_compare = FuncLoader.LoadFunction<d_g_date_time_compare>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_compare"));
 
@@ -351,7 +351,7 @@ namespace GLib {
 			int ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_date_time_equal(IntPtr dt1, IntPtr dt2);
 		static d_g_date_time_equal g_date_time_equal = FuncLoader.LoadFunction<d_g_date_time_equal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_equal"));
 
@@ -360,7 +360,7 @@ namespace GLib {
 			bool ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_date_time_hash(IntPtr datetime);
 		static d_g_date_time_hash g_date_time_hash = FuncLoader.LoadFunction<d_g_date_time_hash>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_hash"));
 
@@ -371,7 +371,7 @@ namespace GLib {
 		}
 
 		public DateTime(IntPtr raw) : base(raw) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_new(IntPtr tz, int year, int month, int day, int hour, int minute, double seconds);
 		static d_g_date_time_new g_date_time_new = FuncLoader.LoadFunction<d_g_date_time_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_new"));
 
@@ -379,7 +379,7 @@ namespace GLib {
 		{
 			Raw = g_date_time_new(tz == null ? IntPtr.Zero : tz.Handle, year, month, day, hour, minute, seconds);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_new_from_timeval_local(IntPtr tv);
 		static d_g_date_time_new_from_timeval_local g_date_time_new_from_timeval_local = FuncLoader.LoadFunction<d_g_date_time_new_from_timeval_local>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_new_from_timeval_local"));
 
@@ -390,7 +390,7 @@ namespace GLib {
 			tv = GLib.TimeVal.New (native_tv);
 			Marshal.FreeHGlobal (native_tv);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_new_from_timeval_utc(IntPtr tv);
 		static d_g_date_time_new_from_timeval_utc g_date_time_new_from_timeval_utc = FuncLoader.LoadFunction<d_g_date_time_new_from_timeval_utc>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_new_from_timeval_utc"));
 
@@ -402,7 +402,7 @@ namespace GLib {
 			Marshal.FreeHGlobal (native_tv);
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_new_from_unix_local(long t);
 		static d_g_date_time_new_from_unix_local g_date_time_new_from_unix_local = FuncLoader.LoadFunction<d_g_date_time_new_from_unix_local>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_new_from_unix_local"));
 
@@ -410,7 +410,7 @@ namespace GLib {
 		{
 			Raw = g_date_time_new_from_unix_local(t);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_new_from_unix_utc(long t);
 		static d_g_date_time_new_from_unix_utc g_date_time_new_from_unix_utc = FuncLoader.LoadFunction<d_g_date_time_new_from_unix_utc>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_new_from_unix_utc"));
 
@@ -419,7 +419,7 @@ namespace GLib {
 			DateTime result = new DateTime (g_date_time_new_from_unix_utc(t));
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_new_local(int year, int month, int day, int hour, int minute, double seconds);
 		static d_g_date_time_new_local g_date_time_new_local = FuncLoader.LoadFunction<d_g_date_time_new_local>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_new_local"));
 
@@ -427,7 +427,7 @@ namespace GLib {
 		{
 			Raw = g_date_time_new_local(year, month, day, hour, minute, seconds);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_new_now(IntPtr tz);
 		static d_g_date_time_new_now g_date_time_new_now = FuncLoader.LoadFunction<d_g_date_time_new_now>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_new_now"));
 
@@ -435,7 +435,7 @@ namespace GLib {
 		{
 			Raw = g_date_time_new_now(tz == null ? IntPtr.Zero : tz.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_new_now_local();
 		static d_g_date_time_new_now_local g_date_time_new_now_local = FuncLoader.LoadFunction<d_g_date_time_new_now_local>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_new_now_local"));
 
@@ -443,7 +443,7 @@ namespace GLib {
 		{
 			Raw = g_date_time_new_now_local();
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_new_now_utc();
 		static d_g_date_time_new_now_utc g_date_time_new_now_utc = FuncLoader.LoadFunction<d_g_date_time_new_now_utc>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_new_now_utc"));
 
@@ -452,7 +452,7 @@ namespace GLib {
 			DateTime result = new DateTime (g_date_time_new_now_utc());
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_new_utc(int year, int month, int day, int hour, int minute, double seconds);
 		static d_g_date_time_new_utc g_date_time_new_utc = FuncLoader.LoadFunction<d_g_date_time_new_utc>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_new_utc"));
 
@@ -461,7 +461,7 @@ namespace GLib {
 			DateTime result = new DateTime (g_date_time_new_utc(year, month, day, hour, minute, seconds));
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_date_time_ref(IntPtr raw);
 		static d_g_date_time_ref g_date_time_ref = FuncLoader.LoadFunction<d_g_date_time_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_ref"));
 
@@ -472,7 +472,7 @@ namespace GLib {
 				Owned = true;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_date_time_unref(IntPtr raw);
 		static d_g_date_time_unref g_date_time_unref = FuncLoader.LoadFunction<d_g_date_time_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_date_time_unref"));
 
@@ -510,3 +510,4 @@ namespace GLib {
 #endregion
 	}
 }
+

Source/Libs/GLibSharp/FileUtils.cs

@@ -26,9 +26,10 @@ namespace GLib {
 
 	public class FileUtils
 	{
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_file_get_contents(IntPtr filename, out IntPtr contents, out int length, out IntPtr error);
 		static d_g_file_get_contents g_file_get_contents = FuncLoader.LoadFunction<d_g_file_get_contents>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_file_get_contents"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_file_get_contents_utf8(IntPtr filename, out IntPtr contents, out int length, out IntPtr error);
 		static d_g_file_get_contents_utf8 g_file_get_contents_utf8 = FuncLoader.LoadFunction<d_g_file_get_contents_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_file_get_contents_utf8"));
 
@@ -53,3 +54,4 @@ namespace GLib {
 		private FileUtils () {}
 	}
 }
+

Source/Libs/GLibSharp/GException.cs

@@ -59,7 +59,7 @@ namespace GLib {
 				return Marshaller.Utf8PtrToString (err.Msg);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_clear_error(ref IntPtr errptr);
 		static d_g_clear_error g_clear_error = FuncLoader.LoadFunction<d_g_clear_error>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_clear_error"));
 		~GException ()
@@ -69,3 +69,4 @@ namespace GLib {
 	}
 }
 
+

Source/Libs/GLibSharp/GString.cs

@@ -26,7 +26,7 @@ namespace GLib {
 	public class GString : GLib.IWrapper {
 
 		IntPtr handle;
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_string_free(IntPtr mem, bool free_segments);
 		static d_g_string_free g_string_free = FuncLoader.LoadFunction<d_g_string_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_string_free"));
 
@@ -34,7 +34,7 @@ namespace GLib {
 		{
 			g_string_free (handle, true);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_string_new(IntPtr text);
 		static d_g_string_new g_string_new = FuncLoader.LoadFunction<d_g_string_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_string_new"));
 
@@ -58,3 +58,4 @@ namespace GLib {
 	}
 }
 
+

Source/Libs/GLibSharp/GType.cs

@@ -430,38 +430,40 @@ namespace GLib {
 		{
 			return GType.Is (ValFromInstancePtr (raw), this);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_type_class_peek(IntPtr gtype);
 		static d_g_type_class_peek g_type_class_peek = FuncLoader.LoadFunction<d_g_type_class_peek>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_class_peek"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_type_class_ref(IntPtr gtype);
 		static d_g_type_class_ref g_type_class_ref = FuncLoader.LoadFunction<d_g_type_class_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_class_ref"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_type_default_interface_peek(IntPtr gtype);
 		static d_g_type_default_interface_peek g_type_default_interface_peek = FuncLoader.LoadFunction<d_g_type_default_interface_peek>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_default_interface_peek"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_type_default_interface_ref(IntPtr gtype);
 		static d_g_type_default_interface_ref g_type_default_interface_ref = FuncLoader.LoadFunction<d_g_type_default_interface_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_default_interface_ref"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_type_from_name(string name);
 		static d_g_type_from_name g_type_from_name = FuncLoader.LoadFunction<d_g_type_from_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_from_name"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_type_init();
 		static d_g_type_init g_type_init = FuncLoader.LoadFunction<d_g_type_init>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_init"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_type_name(IntPtr raw);
 		static d_g_type_name g_type_name = FuncLoader.LoadFunction<d_g_type_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_name"));
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_type_parent(IntPtr type);
 		static d_g_type_parent g_type_parent = FuncLoader.LoadFunction<d_g_type_parent>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_parent"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_type_query(IntPtr type, out GTypeQuery query);
 		static d_g_type_query g_type_query = FuncLoader.LoadFunction<d_g_type_query>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_query"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_type_register_static(IntPtr parent, IntPtr name, ref GTypeInfo info, int flags);
 		static d_g_type_register_static g_type_register_static = FuncLoader.LoadFunction<d_g_type_register_static>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_register_static"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_type_is_a(IntPtr type, IntPtr is_a_type);
 		static d_g_type_is_a g_type_is_a = FuncLoader.LoadFunction<d_g_type_is_a>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_is_a"));
 	}
 }
+

Source/Libs/GLibSharp/Global.cs

@@ -54,10 +54,10 @@ namespace GLib {
 				GLib.Marshaller.Free (native_name);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_set_prgname(IntPtr name);
 		static d_g_set_prgname g_set_prgname = FuncLoader.LoadFunction<d_g_set_prgname>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_set_prgname"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_get_prgname();
 		static d_g_get_prgname g_get_prgname = FuncLoader.LoadFunction<d_g_get_prgname>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_get_prgname"));
 
@@ -71,13 +71,13 @@ namespace GLib {
 				GLib.Marshaller.Free (native_name);				
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_set_application_name(IntPtr name);
 		static d_g_set_application_name g_set_application_name = FuncLoader.LoadFunction<d_g_set_application_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_set_application_name"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_get_application_name();
 		static d_g_get_application_name g_get_application_name = FuncLoader.LoadFunction<d_g_get_application_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_get_application_name"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_format_size_for_display(long size);
 		static d_g_format_size_for_display g_format_size_for_display = FuncLoader.LoadFunction<d_g_format_size_for_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_format_size_for_display"));
 		
@@ -87,3 +87,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GLibSharp/IOChannel.cs

@@ -322,103 +322,103 @@ namespace GLib {
 		{
 			return (IOChannelError) g_io_channel_error_from_errno (en);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_io_channel_unix_new(int fd);
 		static d_g_io_channel_unix_new g_io_channel_unix_new = FuncLoader.LoadFunction<d_g_io_channel_unix_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_unix_new"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_io_channel_new_file(IntPtr filename, IntPtr mode, out IntPtr error);
 		static d_g_io_channel_new_file g_io_channel_new_file = FuncLoader.LoadFunction<d_g_io_channel_new_file>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_new_file"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_io_channel_new_file_utf8(IntPtr filename, IntPtr mode, out IntPtr error);
 		static d_g_io_channel_new_file_utf8 g_io_channel_new_file_utf8 = FuncLoader.LoadFunction<d_g_io_channel_new_file_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_new_file_utf8"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_error_quark();
 		static d_g_io_channel_error_quark g_io_channel_error_quark = FuncLoader.LoadFunction<d_g_io_channel_error_quark>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_error_quark"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_error_from_errno(int en);
 		static d_g_io_channel_error_from_errno g_io_channel_error_from_errno = FuncLoader.LoadFunction<d_g_io_channel_error_from_errno>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_error_from_errno"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_flush(IntPtr raw, out IntPtr error);
 		static d_g_io_channel_flush g_io_channel_flush = FuncLoader.LoadFunction<d_g_io_channel_flush>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_flush"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_io_channel_init(IntPtr raw);
 		static d_g_io_channel_init g_io_channel_init = FuncLoader.LoadFunction<d_g_io_channel_init>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_init"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_read_chars(IntPtr raw, byte[] buf, UIntPtr count, out UIntPtr bytes_read, out IntPtr error);
 		static d_g_io_channel_read_chars g_io_channel_read_chars = FuncLoader.LoadFunction<d_g_io_channel_read_chars>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_read_chars"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_read_line(IntPtr raw, out IntPtr str_return, IntPtr length, out UIntPtr terminator_pos, out IntPtr error);
 		static d_g_io_channel_read_line g_io_channel_read_line = FuncLoader.LoadFunction<d_g_io_channel_read_line>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_read_line"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_read_to_end(IntPtr raw, out IntPtr str_return, out UIntPtr length, out IntPtr error);
 		static d_g_io_channel_read_to_end g_io_channel_read_to_end = FuncLoader.LoadFunction<d_g_io_channel_read_to_end>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_read_to_end"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_read_unichar(IntPtr raw, out uint thechar, out IntPtr error);
 		static d_g_io_channel_read_unichar g_io_channel_read_unichar = FuncLoader.LoadFunction<d_g_io_channel_read_unichar>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_read_unichar"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_seek_position(IntPtr raw, long offset, int type, out IntPtr error);
 		static d_g_io_channel_seek_position g_io_channel_seek_position = FuncLoader.LoadFunction<d_g_io_channel_seek_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_seek_position"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_shutdown(IntPtr raw, bool flush, out IntPtr err);
 		static d_g_io_channel_shutdown g_io_channel_shutdown = FuncLoader.LoadFunction<d_g_io_channel_shutdown>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_shutdown"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_write_chars(IntPtr raw, byte[] buf, IntPtr count, out UIntPtr bytes_written, out IntPtr error);
 		static d_g_io_channel_write_chars g_io_channel_write_chars = FuncLoader.LoadFunction<d_g_io_channel_write_chars>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_write_chars"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_write_unichar(IntPtr raw, uint thechar, out IntPtr error);
 		static d_g_io_channel_write_unichar g_io_channel_write_unichar = FuncLoader.LoadFunction<d_g_io_channel_write_unichar>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_write_unichar"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_get_buffer_condition(IntPtr raw);
 		static d_g_io_channel_get_buffer_condition g_io_channel_get_buffer_condition = FuncLoader.LoadFunction<d_g_io_channel_get_buffer_condition>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_get_buffer_condition"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_io_channel_get_buffered(IntPtr raw);
 		static d_g_io_channel_get_buffered g_io_channel_get_buffered = FuncLoader.LoadFunction<d_g_io_channel_get_buffered>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_get_buffered"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_io_channel_set_buffered(IntPtr raw, bool buffered);
 		static d_g_io_channel_set_buffered g_io_channel_set_buffered = FuncLoader.LoadFunction<d_g_io_channel_set_buffered>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_set_buffered"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate UIntPtr d_g_io_channel_get_buffer_size(IntPtr raw);
 		static d_g_io_channel_get_buffer_size g_io_channel_get_buffer_size = FuncLoader.LoadFunction<d_g_io_channel_get_buffer_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_get_buffer_size"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_io_channel_set_buffer_size(IntPtr raw, UIntPtr size);
 		static d_g_io_channel_set_buffer_size g_io_channel_set_buffer_size = FuncLoader.LoadFunction<d_g_io_channel_set_buffer_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_set_buffer_size"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_io_channel_get_close_on_unref(IntPtr raw);
 		static d_g_io_channel_get_close_on_unref g_io_channel_get_close_on_unref = FuncLoader.LoadFunction<d_g_io_channel_get_close_on_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_get_close_on_unref"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_io_channel_set_close_on_unref(IntPtr raw, bool do_close);
 		static d_g_io_channel_set_close_on_unref g_io_channel_set_close_on_unref = FuncLoader.LoadFunction<d_g_io_channel_set_close_on_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_set_close_on_unref"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_io_channel_get_encoding(IntPtr raw);
 		static d_g_io_channel_get_encoding g_io_channel_get_encoding = FuncLoader.LoadFunction<d_g_io_channel_get_encoding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_get_encoding"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_set_encoding(IntPtr raw, IntPtr encoding, out IntPtr error);
 		static d_g_io_channel_set_encoding g_io_channel_set_encoding = FuncLoader.LoadFunction<d_g_io_channel_set_encoding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_set_encoding"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_get_flags(IntPtr raw);
 		static d_g_io_channel_get_flags g_io_channel_get_flags = FuncLoader.LoadFunction<d_g_io_channel_get_flags>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_get_flags"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_set_flags(IntPtr raw, int flags, out IntPtr error);
 		static d_g_io_channel_set_flags g_io_channel_set_flags = FuncLoader.LoadFunction<d_g_io_channel_set_flags>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_set_flags"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_io_channel_get_line_term(IntPtr raw, out int length);
 		static d_g_io_channel_get_line_term g_io_channel_get_line_term = FuncLoader.LoadFunction<d_g_io_channel_get_line_term>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_get_line_term"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_io_channel_set_line_term(IntPtr raw, byte[] term, int length);
 		static d_g_io_channel_set_line_term g_io_channel_set_line_term = FuncLoader.LoadFunction<d_g_io_channel_set_line_term>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_set_line_term"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_io_channel_unix_get_fd(IntPtr raw);
 		static d_g_io_channel_unix_get_fd g_io_channel_unix_get_fd = FuncLoader.LoadFunction<d_g_io_channel_unix_get_fd>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_unix_get_fd"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_io_channel_ref(IntPtr raw);
 		static d_g_io_channel_ref g_io_channel_ref = FuncLoader.LoadFunction<d_g_io_channel_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_ref"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_io_channel_unref(IntPtr raw);
 		static d_g_io_channel_unref g_io_channel_unref = FuncLoader.LoadFunction<d_g_io_channel_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_channel_unref"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_io_add_watch_full(IntPtr raw, int priority, int condition, IOFuncNative func, IntPtr user_data, DestroyNotify notify);
 		static d_g_io_add_watch_full g_io_add_watch_full = FuncLoader.LoadFunction<d_g_io_add_watch_full>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_add_watch_full"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_io_create_watch(IntPtr raw, int condition);
 		static d_g_io_create_watch g_io_create_watch = FuncLoader.LoadFunction<d_g_io_create_watch>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_io_create_watch"));
 	}
@@ -472,3 +472,4 @@ namespace GLib {
 		End,
 	}
 }
+

Source/Libs/GLibSharp/Idle.cs

@@ -69,6 +69,7 @@ namespace GLib {
 		{
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_idle_add(IdleHandlerInternal d, IntPtr data);
 		static d_g_idle_add g_idle_add = FuncLoader.LoadFunction<d_g_idle_add>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_idle_add"));
 
@@ -83,7 +84,7 @@ namespace GLib {
 
 			return p.ID;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_idle_add_full(int priority, IdleHandlerInternal d, IntPtr data, DestroyNotify notify);
 		static d_g_idle_add_full g_idle_add_full = FuncLoader.LoadFunction<d_g_idle_add_full>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_idle_add_full"));
 
@@ -111,3 +112,4 @@ namespace GLib {
 	}
 }
 
+

Source/Libs/GLibSharp/KeyFile.cs

@@ -538,126 +538,127 @@ namespace GLib {
 			Marshaller.Free (raw_ret);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_free(IntPtr raw);
 		static d_g_key_file_free g_key_file_free = FuncLoader.LoadFunction<d_g_key_file_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_free"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_key_file_get_boolean(IntPtr raw, IntPtr group_name, IntPtr key, out IntPtr error);
 		static d_g_key_file_get_boolean g_key_file_get_boolean = FuncLoader.LoadFunction<d_g_key_file_get_boolean>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_boolean"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_get_boolean_list(IntPtr raw, IntPtr group_name, IntPtr key, out UIntPtr length, out IntPtr error);
 		static d_g_key_file_get_boolean_list g_key_file_get_boolean_list = FuncLoader.LoadFunction<d_g_key_file_get_boolean_list>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_boolean_list"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_get_comment(IntPtr raw, IntPtr group_name, IntPtr key, out IntPtr error);
 		static d_g_key_file_get_comment g_key_file_get_comment = FuncLoader.LoadFunction<d_g_key_file_get_comment>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_comment"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate double d_g_key_file_get_double(IntPtr raw, IntPtr group_name, IntPtr key, out IntPtr error);
 		static d_g_key_file_get_double g_key_file_get_double = FuncLoader.LoadFunction<d_g_key_file_get_double>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_double"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_get_double_list(IntPtr raw, IntPtr group_name, IntPtr key, out UIntPtr length, out IntPtr error);
 		static d_g_key_file_get_double_list g_key_file_get_double_list = FuncLoader.LoadFunction<d_g_key_file_get_double_list>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_double_list"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_get_groups(IntPtr raw, IntPtr dummy);
 		static d_g_key_file_get_groups g_key_file_get_groups = FuncLoader.LoadFunction<d_g_key_file_get_groups>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_groups"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_key_file_get_integer(IntPtr raw, IntPtr group_name, IntPtr key, out IntPtr error);
 		static d_g_key_file_get_integer g_key_file_get_integer = FuncLoader.LoadFunction<d_g_key_file_get_integer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_integer"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_get_integer_list(IntPtr raw, IntPtr group_name, IntPtr key, out UIntPtr length, out IntPtr error);
 		static d_g_key_file_get_integer_list g_key_file_get_integer_list = FuncLoader.LoadFunction<d_g_key_file_get_integer_list>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_integer_list"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_get_keys(IntPtr raw, IntPtr group_name, IntPtr dummy, out IntPtr error);
 		static d_g_key_file_get_keys g_key_file_get_keys = FuncLoader.LoadFunction<d_g_key_file_get_keys>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_keys"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_get_locale_string(IntPtr raw, IntPtr group_name, IntPtr key, IntPtr locale, out IntPtr error);
 		static d_g_key_file_get_locale_string g_key_file_get_locale_string = FuncLoader.LoadFunction<d_g_key_file_get_locale_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_locale_string"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_get_locale_string_list(IntPtr raw, IntPtr group_name, IntPtr key, IntPtr locale, IntPtr dummy, out IntPtr error);
 		static d_g_key_file_get_locale_string_list g_key_file_get_locale_string_list = FuncLoader.LoadFunction<d_g_key_file_get_locale_string_list>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_locale_string_list"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_get_start_group(IntPtr raw);
 		static d_g_key_file_get_start_group g_key_file_get_start_group = FuncLoader.LoadFunction<d_g_key_file_get_start_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_start_group"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_get_string(IntPtr raw, IntPtr group_name, IntPtr key, out IntPtr error);
 		static d_g_key_file_get_string g_key_file_get_string = FuncLoader.LoadFunction<d_g_key_file_get_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_string"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_get_string_list(IntPtr raw, IntPtr group_name, IntPtr key, IntPtr dummy, out IntPtr error);
 		static d_g_key_file_get_string_list g_key_file_get_string_list = FuncLoader.LoadFunction<d_g_key_file_get_string_list>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_string_list"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_get_value(IntPtr raw, IntPtr group_name, IntPtr key, out IntPtr error);
 		static d_g_key_file_get_value g_key_file_get_value = FuncLoader.LoadFunction<d_g_key_file_get_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_get_value"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_key_file_has_group(IntPtr raw, IntPtr group_name);
 		static d_g_key_file_has_group g_key_file_has_group = FuncLoader.LoadFunction<d_g_key_file_has_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_has_group"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_key_file_has_key(IntPtr raw, IntPtr group_name, IntPtr key, out IntPtr error);
 		static d_g_key_file_has_key g_key_file_has_key = FuncLoader.LoadFunction<d_g_key_file_has_key>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_has_key"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_key_file_load_from_data(IntPtr raw, byte[] data, UIntPtr length, int flags, out IntPtr error);
 		static d_g_key_file_load_from_data g_key_file_load_from_data = FuncLoader.LoadFunction<d_g_key_file_load_from_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_load_from_data"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_key_file_load_from_data_dirs(IntPtr raw, IntPtr file, out IntPtr full_path, int flags, out IntPtr error);
 		static d_g_key_file_load_from_data_dirs g_key_file_load_from_data_dirs = FuncLoader.LoadFunction<d_g_key_file_load_from_data_dirs>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_load_from_data_dirs"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_key_file_load_from_dirs(IntPtr raw, IntPtr file, IntPtr search_dirs, out IntPtr full_path, int flags, out IntPtr error);
 		static d_g_key_file_load_from_dirs g_key_file_load_from_dirs = FuncLoader.LoadFunction<d_g_key_file_load_from_dirs>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_load_from_dirs"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_key_file_load_from_file(IntPtr raw, IntPtr file, int flags, out IntPtr error);
 		static d_g_key_file_load_from_file g_key_file_load_from_file = FuncLoader.LoadFunction<d_g_key_file_load_from_file>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_load_from_file"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_new();
 		static d_g_key_file_new g_key_file_new = FuncLoader.LoadFunction<d_g_key_file_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_new"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_key_file_remove_comment(IntPtr raw, IntPtr group_name, IntPtr key, out IntPtr error);
 		static d_g_key_file_remove_comment g_key_file_remove_comment = FuncLoader.LoadFunction<d_g_key_file_remove_comment>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_remove_comment"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_key_file_remove_group(IntPtr raw, IntPtr group_name, out IntPtr error);
 		static d_g_key_file_remove_group g_key_file_remove_group = FuncLoader.LoadFunction<d_g_key_file_remove_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_remove_group"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_key_file_remove_key(IntPtr raw, IntPtr group_name, IntPtr key, out IntPtr error);
 		static d_g_key_file_remove_key g_key_file_remove_key = FuncLoader.LoadFunction<d_g_key_file_remove_key>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_remove_key"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_set_boolean(IntPtr raw, IntPtr group_name, IntPtr key, bool value);
 		static d_g_key_file_set_boolean g_key_file_set_boolean = FuncLoader.LoadFunction<d_g_key_file_set_boolean>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_boolean"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_set_boolean_list(IntPtr raw, IntPtr group_name, IntPtr key, bool[] list, UIntPtr n_list);
 		static d_g_key_file_set_boolean_list g_key_file_set_boolean_list = FuncLoader.LoadFunction<d_g_key_file_set_boolean_list>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_boolean_list"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_key_file_set_comment(IntPtr raw, IntPtr group_name, IntPtr key, IntPtr comment, out IntPtr error);
 		static d_g_key_file_set_comment g_key_file_set_comment = FuncLoader.LoadFunction<d_g_key_file_set_comment>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_comment"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_set_double(IntPtr raw, IntPtr group_name, IntPtr key, double value);
 		static d_g_key_file_set_double g_key_file_set_double = FuncLoader.LoadFunction<d_g_key_file_set_double>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_double"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_set_double_list(IntPtr raw, IntPtr group_name, IntPtr key, double[] list, UIntPtr n_list);
 		static d_g_key_file_set_double_list g_key_file_set_double_list = FuncLoader.LoadFunction<d_g_key_file_set_double_list>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_double_list"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_set_integer(IntPtr raw, IntPtr group_name, IntPtr key, int value);
 		static d_g_key_file_set_integer g_key_file_set_integer = FuncLoader.LoadFunction<d_g_key_file_set_integer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_integer"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_set_integer_list(IntPtr raw, IntPtr group_name, IntPtr key, int[] list, UIntPtr n_list);
 		static d_g_key_file_set_integer_list g_key_file_set_integer_list = FuncLoader.LoadFunction<d_g_key_file_set_integer_list>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_integer_list"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_set_list_separator(IntPtr raw, byte separator);
 		static d_g_key_file_set_list_separator g_key_file_set_list_separator = FuncLoader.LoadFunction<d_g_key_file_set_list_separator>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_list_separator"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_set_locale_string(IntPtr raw, IntPtr group_name, IntPtr key, IntPtr locale, IntPtr value);
 		static d_g_key_file_set_locale_string g_key_file_set_locale_string = FuncLoader.LoadFunction<d_g_key_file_set_locale_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_locale_string"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_set_locale_string_list(IntPtr raw, IntPtr group_name, IntPtr key, IntPtr locale, IntPtr list, UIntPtr length);
 		static d_g_key_file_set_locale_string_list g_key_file_set_locale_string_list = FuncLoader.LoadFunction<d_g_key_file_set_locale_string_list>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_locale_string_list"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_set_string(IntPtr raw, IntPtr group_name, IntPtr key, IntPtr value);
 		static d_g_key_file_set_string g_key_file_set_string = FuncLoader.LoadFunction<d_g_key_file_set_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_string"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_set_string_list(IntPtr raw, IntPtr group_name, IntPtr key, IntPtr list, UIntPtr n_list);
 		static d_g_key_file_set_string_list g_key_file_set_string_list = FuncLoader.LoadFunction<d_g_key_file_set_string_list>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_string_list"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_key_file_set_value(IntPtr raw, IntPtr group_name, IntPtr key, IntPtr value);
 		static d_g_key_file_set_value g_key_file_set_value = FuncLoader.LoadFunction<d_g_key_file_set_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_set_value"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_key_file_to_data(IntPtr raw, out UIntPtr length, IntPtr dummy);
 		static d_g_key_file_to_data g_key_file_to_data = FuncLoader.LoadFunction<d_g_key_file_to_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_key_file_to_data"));
 
 	}
 }
+

Source/Libs/GLibSharp/List.cs

@@ -25,7 +25,7 @@ namespace GLib {
 	using System.Runtime.InteropServices;
 
 	public class List : ListBase {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_list_copy(IntPtr l);
 		static d_g_list_copy g_list_copy = FuncLoader.LoadFunction<d_g_list_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_list_copy"));
 		
@@ -34,6 +34,7 @@ namespace GLib {
 			return new List (g_list_copy (Handle));
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_list_length(IntPtr l);
 		static d_g_list_length g_list_length = FuncLoader.LoadFunction<d_g_list_length>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_list_length"));
 		
@@ -42,6 +43,7 @@ namespace GLib {
 			return g_list_length (list);
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_list_free(IntPtr l);
 		static d_g_list_free g_list_free = FuncLoader.LoadFunction<d_g_list_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_list_free"));
 
@@ -50,7 +52,7 @@ namespace GLib {
 			if (list != IntPtr.Zero)
 				g_list_free (list);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_list_append(IntPtr l, IntPtr raw);
 		static d_g_list_append g_list_append = FuncLoader.LoadFunction<d_g_list_append>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_list_append"));
 
@@ -58,7 +60,7 @@ namespace GLib {
 		{
 			return g_list_append (list, raw);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_list_prepend(IntPtr l, IntPtr raw);
 		static d_g_list_prepend g_list_prepend = FuncLoader.LoadFunction<d_g_list_prepend>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_list_prepend"));
 
@@ -66,7 +68,7 @@ namespace GLib {
 		{
 			return g_list_prepend (list, raw);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_list_nth_data(IntPtr l, uint n);
 		static d_g_list_nth_data g_list_nth_data = FuncLoader.LoadFunction<d_g_list_nth_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_list_nth_data"));
 
@@ -95,3 +97,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GLibSharp/ListBase.cs

@@ -189,7 +189,7 @@ namespace GLib {
 			fullname += type.Name.Substring (1); // IActivatable -> Activatable
 			return fullname + "Adapter";
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_unref(IntPtr item);
 		static d_g_object_unref g_object_unref = FuncLoader.LoadFunction<d_g_object_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_unref"));
 
@@ -287,3 +287,4 @@ namespace GLib {
 		abstract public object Clone ();
 	}
 }
+

Source/Libs/GLibSharp/Log.cs

@@ -122,7 +122,7 @@ namespace GLib {
 			if (handlers == null)
 				handlers = new System.Collections.Generic.Dictionary<uint, GCHandle> ();
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_logv(IntPtr log_domain, LogLevelFlags flags, IntPtr message);
 		static d_g_logv g_logv = FuncLoader.LoadFunction<d_g_logv>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_logv"));
 		
@@ -134,7 +134,7 @@ namespace GLib {
 			Marshaller.Free (ndom);
 			Marshaller.Free (nmessage);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_log_set_handler(IntPtr log_domain, LogLevelFlags flags, LogFuncNative log_func, IntPtr user_data);
 		static d_g_log_set_handler g_log_set_handler = FuncLoader.LoadFunction<d_g_log_set_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_log_set_handler"));
 		
@@ -151,7 +151,7 @@ namespace GLib {
 			handlers [result] = gch;
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_log_remove_handler(IntPtr log_domain, uint handler_id);
 		static d_g_log_remove_handler g_log_remove_handler = FuncLoader.LoadFunction<d_g_log_remove_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_log_remove_handler"));
 
@@ -166,7 +166,7 @@ namespace GLib {
 			g_log_remove_handler (ndom, handlerID);
 			Marshaller.Free (ndom);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate PrintFuncNative d_g_set_print_handler(PrintFuncNative handler);
 		static d_g_set_print_handler g_set_print_handler = FuncLoader.LoadFunction<d_g_set_print_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_set_print_handler"));
 
@@ -178,6 +178,7 @@ namespace GLib {
 			return helper.Invoker;
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate PrintFuncNative d_g_set_printerr_handler(PrintFuncNative handler);
 		static d_g_set_printerr_handler g_set_printerr_handler = FuncLoader.LoadFunction<d_g_set_printerr_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_set_printerr_handler"));
 
@@ -189,6 +190,7 @@ namespace GLib {
 			return helper.Invoker;
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_log_default_handler(IntPtr log_domain, LogLevelFlags log_level, IntPtr message, IntPtr unused_data);
 		static d_g_log_default_handler g_log_default_handler = FuncLoader.LoadFunction<d_g_log_default_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_log_default_handler"));
 
@@ -201,7 +203,7 @@ namespace GLib {
 			Marshaller.Free (ndom);
 			Marshaller.Free (nmess);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate LogLevelFlags d_g_log_set_always_fatal(LogLevelFlags fatal_mask);
 		static d_g_log_set_always_fatal g_log_set_always_fatal = FuncLoader.LoadFunction<d_g_log_set_always_fatal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_log_set_always_fatal"));
 		
@@ -209,7 +211,7 @@ namespace GLib {
 		{
 			return g_log_set_always_fatal (fatalMask);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate LogLevelFlags d_g_log_set_fatal_mask(IntPtr log_domain, LogLevelFlags fatal_mask);
 		static d_g_log_set_fatal_mask g_log_set_fatal_mask = FuncLoader.LoadFunction<d_g_log_set_fatal_mask>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_log_set_fatal_mask"));
 		
@@ -243,7 +245,7 @@ namespace GLib {
 				get { return new LogFunc (Invoke); }
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate LogFuncNative d_g_log_set_default_handler(LogFuncNative log_func, IntPtr user_data);
 		static d_g_log_set_default_handler g_log_set_default_handler = FuncLoader.LoadFunction<d_g_log_set_default_handler>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_log_set_default_handler"));
 		
@@ -288,3 +290,4 @@ namespace GLib {
 	}
 }
 
+

Source/Libs/GLibSharp/MainContext.cs

@@ -26,7 +26,7 @@ namespace GLib {
 
         public class MainContext {
 		IntPtr handle;
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_main_context_new();
 		static d_g_main_context_new g_main_context_new = FuncLoader.LoadFunction<d_g_main_context_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_context_new"));
 
@@ -34,7 +34,7 @@ namespace GLib {
 		{
 			handle = g_main_context_new ();
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_main_context_ref(IntPtr raw);
 		static d_g_main_context_ref g_main_context_ref = FuncLoader.LoadFunction<d_g_main_context_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_context_ref"));
 
@@ -49,7 +49,7 @@ namespace GLib {
 				return handle;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_main_context_unref(IntPtr raw);
 		static d_g_main_context_unref g_main_context_unref = FuncLoader.LoadFunction<d_g_main_context_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_context_unref"));
 
@@ -58,7 +58,7 @@ namespace GLib {
 			g_main_context_unref (handle);
 			handle = IntPtr.Zero;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_main_context_default();
 		static d_g_main_context_default g_main_context_default = FuncLoader.LoadFunction<d_g_main_context_default>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_context_default"));
 
@@ -67,7 +67,7 @@ namespace GLib {
 				return new MainContext (g_main_context_default ());
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_main_context_thread_default();
 		static d_g_main_context_thread_default g_main_context_thread_default = FuncLoader.LoadFunction<d_g_main_context_thread_default>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_context_thread_default"));
 
@@ -78,7 +78,7 @@ namespace GLib {
 				return raw == IntPtr.Zero ? Default : new MainContext (raw);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_main_context_push_thread_default(IntPtr raw);
 		static d_g_main_context_push_thread_default g_main_context_push_thread_default = FuncLoader.LoadFunction<d_g_main_context_push_thread_default>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_context_push_thread_default"));
 
@@ -86,7 +86,7 @@ namespace GLib {
 		{
 			g_main_context_push_thread_default (handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_main_context_pop_thread_default(IntPtr raw);
 		static d_g_main_context_pop_thread_default g_main_context_pop_thread_default = FuncLoader.LoadFunction<d_g_main_context_pop_thread_default>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_context_pop_thread_default"));
 
@@ -95,7 +95,7 @@ namespace GLib {
 			g_main_context_pop_thread_default (handle);
 		}
 
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_main_context_iteration(IntPtr raw, bool may_block);
 		static d_g_main_context_iteration g_main_context_iteration = FuncLoader.LoadFunction<d_g_main_context_iteration>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_context_iteration"));
 
@@ -108,7 +108,7 @@ namespace GLib {
 		{
 			return RunIteration (false);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_main_context_pending(IntPtr raw);
 		static d_g_main_context_pending g_main_context_pending = FuncLoader.LoadFunction<d_g_main_context_pending>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_context_pending"));
 
@@ -118,7 +118,7 @@ namespace GLib {
 				return g_main_context_pending (handle);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_main_context_wakeup(IntPtr raw);
 		static d_g_main_context_wakeup g_main_context_wakeup = FuncLoader.LoadFunction<d_g_main_context_wakeup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_context_wakeup"));
 
@@ -141,7 +141,7 @@ namespace GLib {
 			return Handle.GetHashCode ();
 		}
 
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_main_depth();
 		static d_g_main_depth g_main_depth = FuncLoader.LoadFunction<d_g_main_depth>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_depth"));
 		public static int Depth {
@@ -165,3 +165,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GLibSharp/MainLoop.cs

@@ -25,6 +25,7 @@ namespace GLib {
 	public class MainLoop {
 		private IntPtr handle;
 	
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_main_loop_new(IntPtr context, bool isRunning);
 		static d_g_main_loop_new g_main_loop_new = FuncLoader.LoadFunction<d_g_main_loop_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_loop_new"));
 
@@ -37,6 +38,7 @@ namespace GLib {
 			handle = g_main_loop_new (context.Handle, is_running);
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_main_loop_unref(IntPtr loop);
 		static d_g_main_loop_unref g_main_loop_unref = FuncLoader.LoadFunction<d_g_main_loop_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_loop_unref"));
 
@@ -45,7 +47,7 @@ namespace GLib {
 			g_main_loop_unref (handle);
 			handle = IntPtr.Zero;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_main_loop_is_running(IntPtr loop);
 		static d_g_main_loop_is_running g_main_loop_is_running = FuncLoader.LoadFunction<d_g_main_loop_is_running>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_loop_is_running"));
 
@@ -54,7 +56,7 @@ namespace GLib {
 				return g_main_loop_is_running (handle);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_main_loop_run(IntPtr loop);
 		static d_g_main_loop_run g_main_loop_run = FuncLoader.LoadFunction<d_g_main_loop_run>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_loop_run"));
 
@@ -62,7 +64,7 @@ namespace GLib {
 		{
 			g_main_loop_run (handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_main_loop_quit(IntPtr loop);
 		static d_g_main_loop_quit g_main_loop_quit = FuncLoader.LoadFunction<d_g_main_loop_quit>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_loop_quit"));
 
@@ -70,7 +72,7 @@ namespace GLib {
 		{
 			g_main_loop_quit (handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_main_loop_get_context(IntPtr loop);
 		static d_g_main_loop_get_context g_main_loop_get_context = FuncLoader.LoadFunction<d_g_main_loop_get_context>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_main_loop_get_context"));
 
@@ -96,3 +98,4 @@ namespace GLib {
 	}
 }
 
+

Source/Libs/GLibSharp/ManagedValue.cs

@@ -65,7 +65,7 @@ namespace GLib {
 		static CopyFunc copy;
 		static FreeFunc free;
 		static GType boxed_type = GType.Invalid;
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_boxed_type_register_static(IntPtr typename, CopyFunc copy_func, FreeFunc free_func);
 		static d_g_boxed_type_register_static g_boxed_type_register_static = FuncLoader.LoadFunction<d_g_boxed_type_register_static>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_boxed_type_register_static"));
 		
@@ -146,3 +146,4 @@ namespace GLib {
 	}
 }
 
+

Source/Libs/GLibSharp/Markup.cs

@@ -29,6 +29,7 @@ namespace GLib {
 	public class Markup {
 		private Markup () {}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_markup_escape_text(IntPtr text, int len);
 		static d_g_markup_escape_text g_markup_escape_text = FuncLoader.LoadFunction<d_g_markup_escape_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_markup_escape_text"));
 		
@@ -44,3 +45,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GLibSharp/Marshaller.cs

@@ -30,6 +30,7 @@ namespace GLib {
 
 		private Marshaller () {}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_free(IntPtr mem);
 		static d_g_free g_free = FuncLoader.LoadFunction<d_g_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_free"));
 
@@ -46,7 +47,7 @@ namespace GLib {
 			for (int i = 0; i < ptrs.Length; i++)
 				g_free (ptrs [i]);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_filename_to_utf8(IntPtr mem, int len, IntPtr read, out IntPtr written, out IntPtr error);
 		static d_g_filename_to_utf8 g_filename_to_utf8 = FuncLoader.LoadFunction<d_g_filename_to_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_filename_to_utf8"));
 		
@@ -115,7 +116,7 @@ namespace GLib {
 			}
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_filename_from_utf8(IntPtr mem, int len, IntPtr read, out IntPtr written, out IntPtr error);
 		static d_g_filename_from_utf8 g_filename_from_utf8 = FuncLoader.LoadFunction<d_g_filename_from_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_filename_from_utf8"));
 
@@ -176,7 +177,7 @@ namespace GLib {
 			result [strs.Length] = IntPtr.Zero;
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_strfreev(IntPtr mem);
 		static d_g_strfreev g_strfreev = FuncLoader.LoadFunction<d_g_strfreev>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_strfreev"));
 
@@ -221,7 +222,7 @@ namespace GLib {
 			Free (string_array);
 			return members;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_malloc(UIntPtr size);
 		static d_g_malloc g_malloc = FuncLoader.LoadFunction<d_g_malloc>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_malloc"));
 
@@ -242,10 +243,10 @@ namespace GLib {
 		{
 			return local_epoch.AddSeconds (time_t.ToInt64 () + utc_offset);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_malloc0(UIntPtr size);
 		static d_g_malloc0 g_malloc0 = FuncLoader.LoadFunction<d_g_malloc0>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_malloc0"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_unichar_to_utf8(uint c, IntPtr buf);
 		static d_g_unichar_to_utf8 g_unichar_to_utf8 = FuncLoader.LoadFunction<d_g_unichar_to_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_unichar_to_utf8"));
 
@@ -270,7 +271,7 @@ namespace GLib {
 			g_unichar_to_utf8 (ucs4_char, buf);
 			return PtrToStringGFree (buf);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_utf16_to_ucs4(ref ushort c, IntPtr len, IntPtr d1, IntPtr d2, IntPtr d3);
 		static d_g_utf16_to_ucs4 g_utf16_to_ucs4 = FuncLoader.LoadFunction<d_g_utf16_to_ucs4>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_utf16_to_ucs4"));
 
@@ -381,3 +382,4 @@ namespace GLib {
 	}
 }
 
+

Source/Libs/GLibSharp/Mutex.cs

@@ -15,28 +15,28 @@ namespace GLib {
 			int i1;
 			int i2;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_mutex_clear(IntPtr raw);
 		static d_g_mutex_clear g_mutex_clear = FuncLoader.LoadFunction<d_g_mutex_clear>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_mutex_clear"));
 
 		public void Clear() {
 			g_mutex_clear(Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_mutex_init(IntPtr raw);
 		static d_g_mutex_init g_mutex_init = FuncLoader.LoadFunction<d_g_mutex_init>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_mutex_init"));
 
 		public void Init() {
 			g_mutex_init(Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_mutex_lock(IntPtr raw);
 		static d_g_mutex_lock g_mutex_lock = FuncLoader.LoadFunction<d_g_mutex_lock>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_mutex_lock"));
 
 		public void Lock() {
 			g_mutex_lock(Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_mutex_trylock(IntPtr raw);
 		static d_g_mutex_trylock g_mutex_trylock = FuncLoader.LoadFunction<d_g_mutex_trylock>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_mutex_trylock"));
 
@@ -45,7 +45,7 @@ namespace GLib {
 			bool ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_mutex_unlock(IntPtr raw);
 		static d_g_mutex_unlock g_mutex_unlock = FuncLoader.LoadFunction<d_g_mutex_unlock>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_mutex_unlock"));
 
@@ -58,3 +58,4 @@ namespace GLib {
 #endregion
 	}
 }
+

Source/Libs/GLibSharp/NotifyHandler.cs

@@ -22,6 +22,7 @@ namespace GLib {
 	public delegate void NotifyHandler (object o, NotifyArgs args);
 
 	public class NotifyArgs : GLib.SignalArgs {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_get_name(IntPtr pspec);
 		static d_g_param_spec_get_name g_param_spec_get_name = FuncLoader.LoadFunction<d_g_param_spec_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_get_name"));
 
@@ -33,3 +34,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GLibSharp/Object.cs

@@ -143,10 +143,10 @@ namespace GLib {
 		}
 
 		public static bool WarnOnFinalize { get; set; }
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_object_ref(IntPtr raw);
 		static d_g_object_ref g_object_ref = FuncLoader.LoadFunction<d_g_object_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_ref"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_unref(IntPtr raw);
 		static d_g_object_unref g_object_unref = FuncLoader.LoadFunction<d_g_object_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_unref"));
 		
@@ -464,7 +464,7 @@ namespace GLib {
 				return constructor_handler;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_get_name(IntPtr pspec);
 		static d_g_param_spec_get_name g_param_spec_get_name = FuncLoader.LoadFunction<d_g_param_spec_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_get_name"));
 
@@ -503,7 +503,7 @@ namespace GLib {
 			}
 			return raw;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_class_override_property(IntPtr klass, uint prop_id, IntPtr name);
 		static d_g_object_class_override_property g_object_class_override_property = FuncLoader.LoadFunction<d_g_object_class_override_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_class_override_property"));
 
@@ -519,7 +519,7 @@ namespace GLib {
 			OverrideProperty (declaring_class, idx, name);
 			idx++;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_object_class_find_property(IntPtr klass, IntPtr name);
 		static d_g_object_class_find_property g_object_class_find_property = FuncLoader.LoadFunction<d_g_object_class_find_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_class_find_property"));
 
@@ -529,7 +529,7 @@ namespace GLib {
 			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
 			return g_object_class_find_property (gobjectclass, native_name);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_object_interface_find_property(IntPtr klass, IntPtr name);
 		static d_g_object_interface_find_property g_object_interface_find_property = FuncLoader.LoadFunction<d_g_object_interface_find_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_interface_find_property"));
 
@@ -539,7 +539,7 @@ namespace GLib {
 			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
 			return g_object_interface_find_property (g_iface, native_name);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_class_install_property(IntPtr klass, uint prop_id, IntPtr param_spec);
 		static d_g_object_class_install_property g_object_class_install_property = FuncLoader.LoadFunction<d_g_object_class_install_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_class_install_property"));
 
@@ -630,7 +630,7 @@ namespace GLib {
 				return set_property_handler;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_type_add_interface_static(IntPtr gtype, IntPtr iface_type, ref GInterfaceInfo info);
 		static d_g_type_add_interface_static g_type_add_interface_static = FuncLoader.LoadFunction<d_g_type_add_interface_static>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_add_interface_static"));
 
@@ -668,7 +668,7 @@ namespace GLib {
 		{
 			CreateNativeObject (new string [0], new GLib.Value [0]);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_object_new(IntPtr gtype, IntPtr dummy);
 		static d_g_object_new g_object_new = FuncLoader.LoadFunction<d_g_object_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_new"));
 
@@ -676,7 +676,7 @@ namespace GLib {
 			public IntPtr name;
 			public GLib.Value val;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_object_newv(IntPtr gtype, int n_params, GParameter[] parms);
 		static d_g_object_newv g_object_newv = FuncLoader.LoadFunction<d_g_object_newv>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_newv"));
 
@@ -788,7 +788,7 @@ namespace GLib {
 				return data;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_get_property(IntPtr obj, IntPtr name, ref GLib.Value val);
 		static d_g_object_get_property g_object_get_property = FuncLoader.LoadFunction<d_g_object_get_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_get_property"));
 
@@ -800,7 +800,7 @@ namespace GLib {
 			GLib.Marshaller.Free (native_name);
 			return val;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_set_property(IntPtr obj, IntPtr name, ref GLib.Value val);
 		static d_g_object_set_property g_object_set_property = FuncLoader.LoadFunction<d_g_object_set_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_set_property"));
 
@@ -810,7 +810,7 @@ namespace GLib {
 			g_object_set_property (Raw, native_name, ref val);
 			GLib.Marshaller.Free (native_name);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_notify(IntPtr obj, IntPtr property_name);
 		static d_g_object_notify g_object_notify = FuncLoader.LoadFunction<d_g_object_notify>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_notify"));
 
@@ -871,10 +871,10 @@ namespace GLib {
 		{
 			Signal.OverrideDefaultHandler (gtype, name, cb);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		protected delegate void d_g_signal_chain_from_overridden(IntPtr args, ref GLib.Value retval);
 		protected static d_g_signal_chain_from_overridden g_signal_chain_from_overridden = FuncLoader.LoadFunction<d_g_signal_chain_from_overridden>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_signal_chain_from_overridden"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_type_check_instance_is_a(IntPtr obj, IntPtr gtype);
 		static d_g_type_check_instance_is_a g_type_check_instance_is_a = FuncLoader.LoadFunction<d_g_type_check_instance_is_a>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_check_instance_is_a"));
 
@@ -1112,3 +1112,4 @@ namespace GLib {
 		// End of the ABI representation.
 	}
 }
+

Source/Libs/GLibSharp/ObjectManager.cs

@@ -82,8 +82,9 @@ namespace GLib {
 			}
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_type_parent(IntPtr typ);
 		static d_g_type_parent g_type_parent = FuncLoader.LoadFunction<d_g_type_parent>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_parent"));
 	}
 }
+

Source/Libs/GLibSharp/ParamSpec.cs

@@ -142,64 +142,65 @@ namespace GLib {
 			public uint ref_count;
 			public uint param_id;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_char(IntPtr name, IntPtr nick, IntPtr blurb, sbyte min, sbyte max, sbyte dval, int flags);
 		static d_g_param_spec_char g_param_spec_char = FuncLoader.LoadFunction<d_g_param_spec_char>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_char"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_uchar(IntPtr name, IntPtr nick, IntPtr blurb, byte min, byte max, byte dval, int flags);
 		static d_g_param_spec_uchar g_param_spec_uchar = FuncLoader.LoadFunction<d_g_param_spec_uchar>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_uchar"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_boolean(IntPtr name, IntPtr nick, IntPtr blurb, bool dval, int flags);
 		static d_g_param_spec_boolean g_param_spec_boolean = FuncLoader.LoadFunction<d_g_param_spec_boolean>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_boolean"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_enum(IntPtr name, IntPtr nick, IntPtr blurb, IntPtr enum_type, int dval, int flags);
 		static d_g_param_spec_enum g_param_spec_enum = FuncLoader.LoadFunction<d_g_param_spec_enum>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_enum"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_int(IntPtr name, IntPtr nick, IntPtr blurb, int min, int max, int dval, int flags);
 		static d_g_param_spec_int g_param_spec_int = FuncLoader.LoadFunction<d_g_param_spec_int>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_int"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_uint(IntPtr name, IntPtr nick, IntPtr blurb, uint min, uint max, uint dval, int flags);
 		static d_g_param_spec_uint g_param_spec_uint = FuncLoader.LoadFunction<d_g_param_spec_uint>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_uint"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_long(IntPtr name, IntPtr nick, IntPtr blurb, IntPtr min, IntPtr max, IntPtr dval, int flags);
 		static d_g_param_spec_long g_param_spec_long = FuncLoader.LoadFunction<d_g_param_spec_long>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_long"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_ulong(IntPtr name, IntPtr nick, IntPtr blurb, UIntPtr min, UIntPtr max, UIntPtr dval, int flags);
 		static d_g_param_spec_ulong g_param_spec_ulong = FuncLoader.LoadFunction<d_g_param_spec_ulong>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_ulong"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_int64(IntPtr name, IntPtr nick, IntPtr blurb, long min, long max, long dval, int flags);
 		static d_g_param_spec_int64 g_param_spec_int64 = FuncLoader.LoadFunction<d_g_param_spec_int64>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_int64"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_uint64(IntPtr name, IntPtr nick, IntPtr blurb, ulong min, ulong max, ulong dval, int flags);
 		static d_g_param_spec_uint64 g_param_spec_uint64 = FuncLoader.LoadFunction<d_g_param_spec_uint64>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_uint64"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_float(IntPtr name, IntPtr nick, IntPtr blurb, float min, float max, float dval, int flags);
 		static d_g_param_spec_float g_param_spec_float = FuncLoader.LoadFunction<d_g_param_spec_float>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_float"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_double(IntPtr name, IntPtr nick, IntPtr blurb, double min, double max, double dval, int flags);
 		static d_g_param_spec_double g_param_spec_double = FuncLoader.LoadFunction<d_g_param_spec_double>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_double"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_string(IntPtr name, IntPtr nick, IntPtr blurb, IntPtr dval, int flags);
 		static d_g_param_spec_string g_param_spec_string = FuncLoader.LoadFunction<d_g_param_spec_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_string"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_pointer(IntPtr name, IntPtr nick, IntPtr blurb, int flags);
 		static d_g_param_spec_pointer g_param_spec_pointer = FuncLoader.LoadFunction<d_g_param_spec_pointer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_pointer"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_gtype(IntPtr name, IntPtr nick, IntPtr blurb, IntPtr dval, int flags);
 		static d_g_param_spec_gtype g_param_spec_gtype = FuncLoader.LoadFunction<d_g_param_spec_gtype>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_gtype"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_boxed(IntPtr name, IntPtr nick, IntPtr blurb, IntPtr return_type, int flags);
 		static d_g_param_spec_boxed g_param_spec_boxed = FuncLoader.LoadFunction<d_g_param_spec_boxed>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_boxed"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_param_spec_object(IntPtr name, IntPtr nick, IntPtr blurb, IntPtr return_type, int flags);
 		static d_g_param_spec_object g_param_spec_object = FuncLoader.LoadFunction<d_g_param_spec_object>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_param_spec_object"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_gtype_get_type();
 		static d_g_gtype_get_type g_gtype_get_type = FuncLoader.LoadFunction<d_g_gtype_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_gtype_get_type"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_type_is_a(IntPtr a, IntPtr b);
 		static d_g_type_is_a g_type_is_a = FuncLoader.LoadFunction<d_g_type_is_a>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_is_a"));
 
 	}
 }
 
+

Source/Libs/GLibSharp/PollFD.cs

@@ -23,7 +23,7 @@ namespace GLib {
 				return GLib.PollFD.Zero;
 			return (GLib.PollFD) Marshal.PtrToStructure (raw, typeof (GLib.PollFD));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_pollfd_get_type();
 		static d_g_pollfd_get_type g_pollfd_get_type = FuncLoader.LoadFunction<d_g_pollfd_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_pollfd_get_type"));
 
@@ -65,3 +65,4 @@ namespace GLib {
 #endregion
 	}
 }
+

Source/Libs/GLibSharp/PtrArray.cs

@@ -31,7 +31,7 @@ namespace GLib {
 		private bool managed = false;
 		internal bool elements_owned = false;
 		protected System.Type element_type = null;
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_ptr_array_sized_new(uint n_preallocs);
 		static d_g_ptr_array_sized_new g_ptr_array_sized_new = FuncLoader.LoadFunction<d_g_ptr_array_sized_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_ptr_array_sized_new"));
 
@@ -42,7 +42,7 @@ namespace GLib {
 			managed = owned;
 			this.elements_owned = elements_owned;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_ptr_array_new();
 		static d_g_ptr_array_new g_ptr_array_new = FuncLoader.LoadFunction<d_g_ptr_array_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_ptr_array_new"));
 
@@ -76,10 +76,10 @@ namespace GLib {
 			Dispose (true);
 			GC.SuppressFinalize (this);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_ptr_array_free(IntPtr raw, bool free_seg);
 		static d_g_ptr_array_free g_ptr_array_free = FuncLoader.LoadFunction<d_g_ptr_array_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_ptr_array_free"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_unref(IntPtr item);
 		static d_g_object_unref g_object_unref = FuncLoader.LoadFunction<d_g_object_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_object_unref"));
 
@@ -116,7 +116,7 @@ namespace GLib {
 				return Marshal.ReadIntPtr (Handle);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_ptr_array_add(IntPtr raw, IntPtr val);
 		static d_g_ptr_array_add g_ptr_array_add = FuncLoader.LoadFunction<d_g_ptr_array_add>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_ptr_array_add"));
 
@@ -124,7 +124,7 @@ namespace GLib {
 		{
 			g_ptr_array_add (Handle, val);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_ptr_array_remove(IntPtr raw, IntPtr data);
 		static d_g_ptr_array_remove g_ptr_array_remove = FuncLoader.LoadFunction<d_g_ptr_array_remove>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_ptr_array_remove"));
 
@@ -132,7 +132,7 @@ namespace GLib {
 		{
 			g_ptr_array_remove (Handle, data);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_ptr_array_remove_range(IntPtr raw, uint index, uint length);
 		static d_g_ptr_array_remove_range g_ptr_array_remove_range = FuncLoader.LoadFunction<d_g_ptr_array_remove_range>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_ptr_array_remove_range"));
 
@@ -256,7 +256,7 @@ namespace GLib {
 		{
 			return new ListEnumerator (this);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_ptr_array_copy(IntPtr raw);
 		static d_g_ptr_array_copy g_ptr_array_copy = FuncLoader.LoadFunction<d_g_ptr_array_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_ptr_array_copy"));
 
@@ -267,3 +267,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GLibSharp/RecMutex.cs

@@ -17,28 +17,28 @@ namespace GLib {
 			int i2;
 		}
 
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_rec_mutex_clear(IntPtr raw);
 		static d_g_rec_mutex_clear g_rec_mutex_clear = FuncLoader.LoadFunction<d_g_rec_mutex_clear>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_rec_mutex_clear"));
 
 		public void Clear() {
 			g_rec_mutex_clear(Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_rec_mutex_init(IntPtr raw);
 		static d_g_rec_mutex_init g_rec_mutex_init = FuncLoader.LoadFunction<d_g_rec_mutex_init>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_rec_mutex_init"));
 
 		public void Init() {
 			g_rec_mutex_init(Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_rec_mutex_lock(IntPtr raw);
 		static d_g_rec_mutex_lock g_rec_mutex_lock = FuncLoader.LoadFunction<d_g_rec_mutex_lock>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_rec_mutex_lock"));
 
 		public void Lock() {
 			g_rec_mutex_lock(Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_rec_mutex_trylock(IntPtr raw);
 		static d_g_rec_mutex_trylock g_rec_mutex_trylock = FuncLoader.LoadFunction<d_g_rec_mutex_trylock>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_rec_mutex_trylock"));
 
@@ -47,7 +47,7 @@ namespace GLib {
 			bool ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_rec_mutex_unlock(IntPtr raw);
 		static d_g_rec_mutex_unlock g_rec_mutex_unlock = FuncLoader.LoadFunction<d_g_rec_mutex_unlock>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_rec_mutex_unlock"));
 
@@ -60,3 +60,4 @@ namespace GLib {
 #endregion
 	}
 }
+

Source/Libs/GLibSharp/SList.cs

@@ -25,7 +25,7 @@ namespace GLib {
 	using System.Runtime.InteropServices;
 
 	public class SList : ListBase {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_slist_copy(IntPtr l);
 		static d_g_slist_copy g_slist_copy = FuncLoader.LoadFunction<d_g_slist_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_slist_copy"));
 		
@@ -34,6 +34,7 @@ namespace GLib {
 			return new SList (g_slist_copy (Handle));
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_slist_length(IntPtr l);
 		static d_g_slist_length g_slist_length = FuncLoader.LoadFunction<d_g_slist_length>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_slist_length"));
 		
@@ -42,6 +43,7 @@ namespace GLib {
 			return g_slist_length (list);
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_slist_free(IntPtr l);
 		static d_g_slist_free g_slist_free = FuncLoader.LoadFunction<d_g_slist_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_slist_free"));
 
@@ -50,7 +52,7 @@ namespace GLib {
 			if (list != IntPtr.Zero)
 				g_slist_free (list);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_slist_append(IntPtr l, IntPtr raw);
 		static d_g_slist_append g_slist_append = FuncLoader.LoadFunction<d_g_slist_append>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_slist_append"));
 
@@ -58,7 +60,7 @@ namespace GLib {
 		{
 			return g_slist_append (list, raw);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_slist_prepend(IntPtr l, IntPtr raw);
 		static d_g_slist_prepend g_slist_prepend = FuncLoader.LoadFunction<d_g_slist_prepend>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_slist_prepend"));
 
@@ -67,7 +69,7 @@ namespace GLib {
 			return g_slist_prepend (list, raw);
 		}
 
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_slist_nth_data(IntPtr l, uint n);
 		static d_g_slist_nth_data g_slist_nth_data = FuncLoader.LoadFunction<d_g_slist_nth_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_slist_nth_data"));
 
@@ -97,3 +99,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GLibSharp/Signal.cs

@@ -356,35 +356,42 @@ namespace GLib {
 			uint id = GetSignalId (name, gtype.Val);
 			g_signal_override_class_closure (id, gtype.Val, closure);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_cclosure_new(Delegate cb, IntPtr data, IntPtr notify);
 		static d_g_cclosure_new g_cclosure_new = FuncLoader.LoadFunction<d_g_cclosure_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_cclosure_new"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_signal_get_invocation_hint(IntPtr instance);
 		static d_g_signal_get_invocation_hint g_signal_get_invocation_hint = FuncLoader.LoadFunction<d_g_signal_get_invocation_hint>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_signal_get_invocation_hint"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_signal_emitv(IntPtr instance_and_params, uint signal_id, uint gquark_detail, ref GLib.Value return_value);
 		static d_g_signal_emitv g_signal_emitv = FuncLoader.LoadFunction<d_g_signal_emitv>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_signal_emitv"));
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_signal_emitv2(IntPtr instance_and_params, uint signal_id, uint gquark_detail, IntPtr return_value);
 		static d_g_signal_emitv2 g_signal_emitv2 = FuncLoader.LoadFunction<d_g_signal_emitv2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_signal_emitv"));
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_signal_lookup(IntPtr name, IntPtr itype);
 		static d_g_signal_lookup g_signal_lookup = FuncLoader.LoadFunction<d_g_signal_lookup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_signal_lookup"));
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_signal_override_class_closure(uint id, IntPtr gtype, IntPtr closure);
 		static d_g_signal_override_class_closure g_signal_override_class_closure = FuncLoader.LoadFunction<d_g_signal_override_class_closure>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_signal_override_class_closure"));
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_signal_query(uint signal_id, out Query query);
 		static d_g_signal_query g_signal_query = FuncLoader.LoadFunction<d_g_signal_query>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_signal_query"));
 
 		//better not to expose g_quark_from_static_string () due to memory allocation issues
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_quark_from_string(IntPtr str);
 		static d_g_quark_from_string g_quark_from_string = FuncLoader.LoadFunction<d_g_quark_from_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_quark_from_string"));
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate ulong d_g_signal_add_emission_hook(uint signal_id, uint gquark_detail, EmissionHookNative hook_func, IntPtr hook_data, IntPtr data_destroy);
 		static d_g_signal_add_emission_hook g_signal_add_emission_hook = FuncLoader.LoadFunction<d_g_signal_add_emission_hook>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_signal_add_emission_hook"));
 
 	}
 }
 
+

Source/Libs/GLibSharp/SignalClosure.cs

@@ -200,27 +200,28 @@ namespace GLib {
 				return notify_handler;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_cclosure_new(Delegate cb, IntPtr user_data, ClosureNotify notify);
 		static d_g_cclosure_new g_cclosure_new = FuncLoader.LoadFunction<d_g_cclosure_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_cclosure_new"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_closure_new_simple(int closure_size, IntPtr dummy);
 		static d_g_closure_new_simple g_closure_new_simple = FuncLoader.LoadFunction<d_g_closure_new_simple>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_closure_new_simple"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_closure_set_marshal(IntPtr closure, ClosureMarshal marshaler);
 		static d_g_closure_set_marshal g_closure_set_marshal = FuncLoader.LoadFunction<d_g_closure_set_marshal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_closure_set_marshal"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_closure_add_finalize_notifier(IntPtr closure, IntPtr dummy, ClosureNotify notify);
 		static d_g_closure_add_finalize_notifier g_closure_add_finalize_notifier = FuncLoader.LoadFunction<d_g_closure_add_finalize_notifier>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_closure_add_finalize_notifier"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_signal_connect_closure(IntPtr obj, IntPtr name, IntPtr closure, bool is_after);
 		static d_g_signal_connect_closure g_signal_connect_closure = FuncLoader.LoadFunction<d_g_signal_connect_closure>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_signal_connect_closure"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_signal_handler_disconnect(IntPtr instance, uint handler);
 		static d_g_signal_handler_disconnect g_signal_handler_disconnect = FuncLoader.LoadFunction<d_g_signal_handler_disconnect>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_signal_handler_disconnect"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_signal_handler_is_connected(IntPtr instance, uint handler);
 		static d_g_signal_handler_is_connected g_signal_handler_is_connected = FuncLoader.LoadFunction<d_g_signal_handler_is_connected>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_signal_handler_is_connected"));
 	}
 }
 
+

Source/Libs/GLibSharp/Source.cs

@@ -75,7 +75,7 @@ namespace GLib {
 		private Source () {}
 
 		public Source(IntPtr raw) : base(raw) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_source_new(IntPtr source_funcs, uint struct_size);
 		static d_g_source_new g_source_new = FuncLoader.LoadFunction<d_g_source_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_new"));
 
@@ -146,7 +146,7 @@ namespace GLib {
 
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_source_remove(uint tag);
 		static d_g_source_remove g_source_remove = FuncLoader.LoadFunction<d_g_source_remove>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_remove"));
 
@@ -162,7 +162,7 @@ namespace GLib {
 			}
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_source_get_type();
 		static d_g_source_get_type g_source_get_type = FuncLoader.LoadFunction<d_g_source_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_get_type"));
 
@@ -173,7 +173,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_source_get_context(IntPtr raw);
 		static d_g_source_get_context g_source_get_context = FuncLoader.LoadFunction<d_g_source_get_context>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_get_context"));
 
@@ -184,10 +184,10 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_source_get_priority(IntPtr raw);
 		static d_g_source_get_priority g_source_get_priority = FuncLoader.LoadFunction<d_g_source_get_priority>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_get_priority"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_set_priority(IntPtr raw, int priority);
 		static d_g_source_set_priority g_source_set_priority = FuncLoader.LoadFunction<d_g_source_set_priority>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_set_priority"));
 
@@ -201,10 +201,10 @@ namespace GLib {
 				g_source_set_priority(Handle, value);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_source_get_name(IntPtr raw);
 		static d_g_source_get_name g_source_get_name = FuncLoader.LoadFunction<d_g_source_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_get_name"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_set_name(IntPtr raw, IntPtr name);
 		static d_g_source_set_name g_source_set_name = FuncLoader.LoadFunction<d_g_source_set_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_set_name"));
 
@@ -220,14 +220,14 @@ namespace GLib {
 				GLib.Marshaller.Free (native_value);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_add_child_source(IntPtr raw, IntPtr child_source);
 		static d_g_source_add_child_source g_source_add_child_source = FuncLoader.LoadFunction<d_g_source_add_child_source>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_add_child_source"));
 
 		public void AddChildSource(GLib.Source child_source) {
 			g_source_add_child_source(Handle, child_source == null ? IntPtr.Zero : child_source.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_add_poll(IntPtr raw, IntPtr fd);
 		static d_g_source_add_poll g_source_add_poll = FuncLoader.LoadFunction<d_g_source_add_poll>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_add_poll"));
 
@@ -237,7 +237,7 @@ namespace GLib {
 			fd = GLib.PollFD.New (native_fd);
 			Marshal.FreeHGlobal (native_fd);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_source_attach(IntPtr raw, IntPtr context);
 		static d_g_source_attach g_source_attach = FuncLoader.LoadFunction<d_g_source_attach>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_attach"));
 
@@ -250,10 +250,10 @@ namespace GLib {
 		uint Attach() {
 			return Attach (null);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_source_get_can_recurse(IntPtr raw);
 		static d_g_source_get_can_recurse g_source_get_can_recurse = FuncLoader.LoadFunction<d_g_source_get_can_recurse>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_get_can_recurse"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_set_can_recurse(IntPtr raw, bool can_recurse);
 		static d_g_source_set_can_recurse g_source_set_can_recurse = FuncLoader.LoadFunction<d_g_source_set_can_recurse>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_set_can_recurse"));
 
@@ -267,7 +267,7 @@ namespace GLib {
 				g_source_set_can_recurse(Handle, value);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_get_current_time(IntPtr raw, IntPtr timeval);
 		static d_g_source_get_current_time g_source_get_current_time = FuncLoader.LoadFunction<d_g_source_get_current_time>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_get_current_time"));
 
@@ -278,7 +278,7 @@ namespace GLib {
 			timeval = GLib.TimeVal.New (native_timeval);
 			Marshal.FreeHGlobal (native_timeval);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_source_get_id(IntPtr raw);
 		static d_g_source_get_id g_source_get_id = FuncLoader.LoadFunction<d_g_source_get_id>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_get_id"));
 
@@ -289,10 +289,10 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate long d_g_source_get_ready_time(IntPtr raw);
 		static d_g_source_get_ready_time g_source_get_ready_time = FuncLoader.LoadFunction<d_g_source_get_ready_time>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_get_ready_time"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_set_ready_time(IntPtr raw, long ready_time);
 		static d_g_source_set_ready_time g_source_set_ready_time = FuncLoader.LoadFunction<d_g_source_set_ready_time>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_set_ready_time"));
 
@@ -306,7 +306,7 @@ namespace GLib {
 				g_source_set_ready_time(Handle, value);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate long d_g_source_get_time(IntPtr raw);
 		static d_g_source_get_time g_source_get_time = FuncLoader.LoadFunction<d_g_source_get_time>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_get_time"));
 
@@ -317,7 +317,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_source_is_destroyed(IntPtr raw);
 		static d_g_source_is_destroyed g_source_is_destroyed = FuncLoader.LoadFunction<d_g_source_is_destroyed>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_is_destroyed"));
 
@@ -328,14 +328,14 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_modify_unix_fd(IntPtr raw, IntPtr tag, int new_events);
 		static d_g_source_modify_unix_fd g_source_modify_unix_fd = FuncLoader.LoadFunction<d_g_source_modify_unix_fd>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_modify_unix_fd"));
 
 		public void ModifyUnixFd(IntPtr tag, GLib.IOCondition new_events) {
 			g_source_modify_unix_fd(Handle, tag, (int) new_events);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_source_query_unix_fd(IntPtr raw, IntPtr tag);
 		static d_g_source_query_unix_fd g_source_query_unix_fd = FuncLoader.LoadFunction<d_g_source_query_unix_fd>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_query_unix_fd"));
 
@@ -344,14 +344,14 @@ namespace GLib {
 			GLib.IOCondition ret = (GLib.IOCondition) raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_remove_child_source(IntPtr raw, IntPtr child_source);
 		static d_g_source_remove_child_source g_source_remove_child_source = FuncLoader.LoadFunction<d_g_source_remove_child_source>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_remove_child_source"));
 
 		public void RemoveChildSource(GLib.Source child_source) {
 			g_source_remove_child_source(Handle, child_source == null ? IntPtr.Zero : child_source.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_remove_poll(IntPtr raw, IntPtr fd);
 		static d_g_source_remove_poll g_source_remove_poll = FuncLoader.LoadFunction<d_g_source_remove_poll>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_remove_poll"));
 
@@ -361,14 +361,14 @@ namespace GLib {
 			fd = GLib.PollFD.New (native_fd);
 			Marshal.FreeHGlobal (native_fd);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_remove_unix_fd(IntPtr raw, IntPtr tag);
 		static d_g_source_remove_unix_fd g_source_remove_unix_fd = FuncLoader.LoadFunction<d_g_source_remove_unix_fd>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_remove_unix_fd"));
 
 		public void RemoveUnixFd(IntPtr tag) {
 			g_source_remove_unix_fd(Handle, tag);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_set_callback_indirect(IntPtr raw, IntPtr callback_data, IntPtr callback_funcs);
 		static d_g_source_set_callback_indirect g_source_set_callback_indirect = FuncLoader.LoadFunction<d_g_source_set_callback_indirect>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_set_callback_indirect"));
 
@@ -378,7 +378,7 @@ namespace GLib {
 			callback_funcs = GLib.SourceCallbackFuncs.New (native_callback_funcs);
 			Marshal.FreeHGlobal (native_callback_funcs);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_set_funcs(IntPtr raw, IntPtr value);
 		static d_g_source_set_funcs g_source_set_funcs = FuncLoader.LoadFunction<d_g_source_set_funcs>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_set_funcs"));
 
@@ -390,7 +390,7 @@ namespace GLib {
 				Marshal.FreeHGlobal (native_value);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_source_remove_by_funcs_user_data(IntPtr funcs, IntPtr user_data);
 		static d_g_source_remove_by_funcs_user_data g_source_remove_by_funcs_user_data = FuncLoader.LoadFunction<d_g_source_remove_by_funcs_user_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_remove_by_funcs_user_data"));
 
@@ -402,7 +402,7 @@ namespace GLib {
 			Marshal.FreeHGlobal (native_funcs);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_source_remove_by_user_data(IntPtr user_data);
 		static d_g_source_remove_by_user_data g_source_remove_by_user_data = FuncLoader.LoadFunction<d_g_source_remove_by_user_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_remove_by_user_data"));
 
@@ -411,7 +411,7 @@ namespace GLib {
 			bool ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_set_name_by_id(uint tag, IntPtr name);
 		static d_g_source_set_name_by_id g_source_set_name_by_id = FuncLoader.LoadFunction<d_g_source_set_name_by_id>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_set_name_by_id"));
 
@@ -420,7 +420,7 @@ namespace GLib {
 			g_source_set_name_by_id(tag, native_name);
 			GLib.Marshaller.Free (native_name);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_source_ref(IntPtr raw);
 		static d_g_source_ref g_source_ref = FuncLoader.LoadFunction<d_g_source_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_ref"));
 
@@ -431,7 +431,7 @@ namespace GLib {
 				Owned = true;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_unref(IntPtr raw);
 		static d_g_source_unref g_source_unref = FuncLoader.LoadFunction<d_g_source_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_unref"));
 
@@ -442,7 +442,7 @@ namespace GLib {
 				Owned = false;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_source_destroy(IntPtr raw);
 		static d_g_source_destroy g_source_destroy = FuncLoader.LoadFunction<d_g_source_destroy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_source_destroy"));
 
@@ -452,3 +452,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GLibSharp/Spawn.cs

@@ -101,7 +101,7 @@ namespace GLib {
 		{
 			this.pid = pid;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_spawn_close_pid(int pid);
 		static d_g_spawn_close_pid g_spawn_close_pid = FuncLoader.LoadFunction<d_g_spawn_close_pid>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_spawn_close_pid"));
 
@@ -109,10 +109,10 @@ namespace GLib {
 		{
 			g_spawn_close_pid ((int) pid);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_spawn_async(IntPtr dir, IntPtr[] argv, IntPtr[] envp, int flags, SpawnChildSetupFuncNative func, IntPtr data, out int pid, out IntPtr error);
 		static d_g_spawn_async g_spawn_async = FuncLoader.LoadFunction<d_g_spawn_async>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_spawn_async"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_spawn_async_utf8(IntPtr dir, IntPtr[] argv, IntPtr[] envp, int flags, SpawnChildSetupFuncNative func, IntPtr data, out int pid, out IntPtr error);
 		static d_g_spawn_async_utf8 g_spawn_async_utf8 = FuncLoader.LoadFunction<d_g_spawn_async_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_spawn_async_utf8"));
 
@@ -138,10 +138,10 @@ namespace GLib {
 			if (error != IntPtr.Zero) throw new GLib.GException (error);
 			return result;
 		}  
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_spawn_async_with_pipes(IntPtr dir, IntPtr[] argv, IntPtr[] envp, int flags, SpawnChildSetupFuncNative func, IntPtr data, out int pid, IntPtr stdin, IntPtr stdout, IntPtr stderr, out IntPtr error);
 		static d_g_spawn_async_with_pipes g_spawn_async_with_pipes = FuncLoader.LoadFunction<d_g_spawn_async_with_pipes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_spawn_async_with_pipes"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_spawn_async_with_pipes_utf8(IntPtr dir, IntPtr[] argv, IntPtr[] envp, int flags, SpawnChildSetupFuncNative func, IntPtr data, out int pid, IntPtr stdin, IntPtr stdout, IntPtr stderr, out IntPtr error);
 		static d_g_spawn_async_with_pipes_utf8 g_spawn_async_with_pipes_utf8 = FuncLoader.LoadFunction<d_g_spawn_async_with_pipes_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_spawn_async_with_pipes_utf8"));
 
@@ -182,10 +182,10 @@ namespace GLib {
 			if (error != IntPtr.Zero) throw new GLib.GException (error);
 			return result;
 		}  
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_spawn_sync(IntPtr dir, IntPtr[] argv, IntPtr[] envp, int flags, SpawnChildSetupFuncNative func, IntPtr data, out IntPtr stdout, out IntPtr stderr, out int exit_status, out IntPtr error);
 		static d_g_spawn_sync g_spawn_sync = FuncLoader.LoadFunction<d_g_spawn_sync>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_spawn_sync"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_spawn_sync_utf8(IntPtr dir, IntPtr[] argv, IntPtr[] envp, int flags, SpawnChildSetupFuncNative func, IntPtr data, out IntPtr stdout, out IntPtr stderr, out int exit_status, out IntPtr error);
 		static d_g_spawn_sync_utf8 g_spawn_sync_utf8 = FuncLoader.LoadFunction<d_g_spawn_sync_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_spawn_sync_utf8"));
 
@@ -211,10 +211,10 @@ namespace GLib {
 			if (error != IntPtr.Zero) throw new GLib.GException (error);
 			return result;
 		}  
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_spawn_command_line_async(IntPtr cmdline, out IntPtr error);
 		static d_g_spawn_command_line_async g_spawn_command_line_async = FuncLoader.LoadFunction<d_g_spawn_command_line_async>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_spawn_command_line_async"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_spawn_command_line_async_utf8(IntPtr cmdline, out IntPtr error);
 		static d_g_spawn_command_line_async_utf8 g_spawn_command_line_async_utf8 = FuncLoader.LoadFunction<d_g_spawn_command_line_async_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_spawn_command_line_async_utf8"));
 
@@ -233,10 +233,10 @@ namespace GLib {
 			if (error != IntPtr.Zero) throw new GLib.GException (error);
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_spawn_command_line_sync(IntPtr cmdline, out IntPtr stdout, out IntPtr stderr, out int exit_status, out IntPtr error);
 		static d_g_spawn_command_line_sync g_spawn_command_line_sync = FuncLoader.LoadFunction<d_g_spawn_command_line_sync>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_spawn_command_line_sync"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_spawn_command_line_sync_utf8(IntPtr cmdline, out IntPtr stdout, out IntPtr stderr, out int exit_status, out IntPtr error);
 		static d_g_spawn_command_line_sync_utf8 g_spawn_command_line_sync_utf8 = FuncLoader.LoadFunction<d_g_spawn_command_line_sync_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_spawn_command_line_sync_utf8"));
 
@@ -259,3 +259,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GLibSharp/TimeVal.cs

@@ -38,7 +38,7 @@ namespace GLib {
 				return GLib.TimeVal.Zero;
 			return (GLib.TimeVal) Marshal.PtrToStructure (raw, typeof (GLib.TimeVal));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_time_val_add(IntPtr raw, IntPtr microseconds);
 		static d_g_time_val_add g_time_val_add = FuncLoader.LoadFunction<d_g_time_val_add>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_val_add"));
 
@@ -49,7 +49,7 @@ namespace GLib {
 			ReadNative (this_as_native, ref this);
 			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_time_val_to_iso8601(IntPtr raw);
 		static d_g_time_val_to_iso8601 g_time_val_to_iso8601 = FuncLoader.LoadFunction<d_g_time_val_to_iso8601>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_val_to_iso8601"));
 
@@ -62,7 +62,7 @@ namespace GLib {
 			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_time_val_from_iso8601(IntPtr iso_date, IntPtr time_);
 		static d_g_time_val_from_iso8601 g_time_val_from_iso8601 = FuncLoader.LoadFunction<d_g_time_val_from_iso8601>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_val_from_iso8601"));
 
@@ -103,3 +103,4 @@ namespace GLib {
 #endregion
 	}
 }
+

Source/Libs/GLibSharp/TimeZone.cs

@@ -10,7 +10,7 @@ namespace GLib {
 
 #region Autogenerated code
 	public partial class TimeZone : GLib.Opaque {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_time_zone_get_type();
 		static d_g_time_zone_get_type g_time_zone_get_type = FuncLoader.LoadFunction<d_g_time_zone_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_zone_get_type"));
 
@@ -21,7 +21,7 @@ namespace GLib {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_time_zone_adjust_time(IntPtr raw, int type, long time_);
 		static d_g_time_zone_adjust_time g_time_zone_adjust_time = FuncLoader.LoadFunction<d_g_time_zone_adjust_time>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_zone_adjust_time"));
 
@@ -30,7 +30,7 @@ namespace GLib {
 			int ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_time_zone_find_interval(IntPtr raw, int type, long time_);
 		static d_g_time_zone_find_interval g_time_zone_find_interval = FuncLoader.LoadFunction<d_g_time_zone_find_interval>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_zone_find_interval"));
 
@@ -39,7 +39,7 @@ namespace GLib {
 			int ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_time_zone_get_abbreviation(IntPtr raw, int interval);
 		static d_g_time_zone_get_abbreviation g_time_zone_get_abbreviation = FuncLoader.LoadFunction<d_g_time_zone_get_abbreviation>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_zone_get_abbreviation"));
 
@@ -48,7 +48,7 @@ namespace GLib {
 			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_time_zone_get_offset(IntPtr raw, int interval);
 		static d_g_time_zone_get_offset g_time_zone_get_offset = FuncLoader.LoadFunction<d_g_time_zone_get_offset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_zone_get_offset"));
 
@@ -57,7 +57,7 @@ namespace GLib {
 			int ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_time_zone_is_dst(IntPtr raw, int interval);
 		static d_g_time_zone_is_dst g_time_zone_is_dst = FuncLoader.LoadFunction<d_g_time_zone_is_dst>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_zone_is_dst"));
 
@@ -68,7 +68,7 @@ namespace GLib {
 		}
 
 		public TimeZone(IntPtr raw) : base(raw) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_time_zone_new(IntPtr identifier);
 		static d_g_time_zone_new g_time_zone_new = FuncLoader.LoadFunction<d_g_time_zone_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_zone_new"));
 
@@ -78,7 +78,7 @@ namespace GLib {
 			Raw = g_time_zone_new(native_identifier);
 			GLib.Marshaller.Free (native_identifier);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_time_zone_new_local();
 		static d_g_time_zone_new_local g_time_zone_new_local = FuncLoader.LoadFunction<d_g_time_zone_new_local>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_zone_new_local"));
 
@@ -86,7 +86,7 @@ namespace GLib {
 		{
 			Raw = g_time_zone_new_local();
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_time_zone_new_utc();
 		static d_g_time_zone_new_utc g_time_zone_new_utc = FuncLoader.LoadFunction<d_g_time_zone_new_utc>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_zone_new_utc"));
 
@@ -95,7 +95,7 @@ namespace GLib {
 			TimeZone result = new TimeZone (g_time_zone_new_utc());
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_time_zone_ref(IntPtr raw);
 		static d_g_time_zone_ref g_time_zone_ref = FuncLoader.LoadFunction<d_g_time_zone_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_zone_ref"));
 
@@ -106,7 +106,7 @@ namespace GLib {
 				Owned = true;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_time_zone_unref(IntPtr raw);
 		static d_g_time_zone_unref g_time_zone_unref = FuncLoader.LoadFunction<d_g_time_zone_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_time_zone_unref"));
 
@@ -144,3 +144,4 @@ namespace GLib {
 #endregion
 	}
 }
+

Source/Libs/GLibSharp/Timeout.cs

@@ -64,6 +64,7 @@ namespace GLib {
 		}
 		
 		private Timeout () {} 
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_timeout_add(uint interval, TimeoutHandlerInternal d, IntPtr data);
 		static d_g_timeout_add g_timeout_add = FuncLoader.LoadFunction<d_g_timeout_add>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_timeout_add"));
 
@@ -78,7 +79,7 @@ namespace GLib {
 
 			return p.ID;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_timeout_add_full(int priority, uint interval, TimeoutHandlerInternal d, IntPtr data, DestroyNotify notify);
 		static d_g_timeout_add_full g_timeout_add_full = FuncLoader.LoadFunction<d_g_timeout_add_full>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_timeout_add_full"));
 
@@ -93,7 +94,7 @@ namespace GLib {
 
 			return p.ID;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_timeout_add_seconds(uint interval, TimeoutHandlerInternal d, IntPtr data);
 		static d_g_timeout_add_seconds g_timeout_add_seconds = FuncLoader.LoadFunction<d_g_timeout_add_seconds>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_timeout_add_seconds"));
 
@@ -121,3 +122,4 @@ namespace GLib {
 	}
 }
 
+

Source/Libs/GLibSharp/ToggleRef.cs

@@ -157,18 +157,19 @@ namespace GLib {
 
 			return false;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_add_toggle_ref(IntPtr raw, ToggleNotifyHandler notify_cb, IntPtr data);
 		static d_g_object_add_toggle_ref g_object_add_toggle_ref = FuncLoader.LoadFunction<d_g_object_add_toggle_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_add_toggle_ref"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_remove_toggle_ref(IntPtr raw, ToggleNotifyHandler notify_cb, IntPtr data);
 		static d_g_object_remove_toggle_ref g_object_remove_toggle_ref = FuncLoader.LoadFunction<d_g_object_remove_toggle_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_remove_toggle_ref"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_object_ref(IntPtr raw);
 		static d_g_object_ref g_object_ref = FuncLoader.LoadFunction<d_g_object_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_ref"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_unref(IntPtr raw);
 		static d_g_object_unref g_object_unref = FuncLoader.LoadFunction<d_g_object_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_unref"));
 
 	}
 }
+

Source/Libs/GLibSharp/Value.cs

@@ -609,146 +609,148 @@ namespace GLib {
 			ParamSpec spec = new ParamSpec (spec_ptr);
 			g_value_init (ref this, spec.ValueType.Val);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_object_class_find_property(IntPtr klass, IntPtr name);
 		static d_g_object_class_find_property g_object_class_find_property = FuncLoader.LoadFunction<d_g_object_class_find_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_class_find_property"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_type_check_value_holds(ref Value val, IntPtr gtype);
 		static d_g_type_check_value_holds g_type_check_value_holds = FuncLoader.LoadFunction<d_g_type_check_value_holds>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_type_check_value_holds"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_init(ref GLib.Value val, IntPtr gtype);
 		static d_g_value_init g_value_init = FuncLoader.LoadFunction<d_g_value_init>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_init"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_unset(ref GLib.Value val);
 		static d_g_value_unset g_value_unset = FuncLoader.LoadFunction<d_g_value_unset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_unset"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_boolean(ref Value val, bool data);
 		static d_g_value_set_boolean g_value_set_boolean = FuncLoader.LoadFunction<d_g_value_set_boolean>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_boolean"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_uchar(ref Value val, byte data);
 		static d_g_value_set_uchar g_value_set_uchar = FuncLoader.LoadFunction<d_g_value_set_uchar>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_uchar"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_char(ref Value val, sbyte data);
 		static d_g_value_set_char g_value_set_char = FuncLoader.LoadFunction<d_g_value_set_char>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_char"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_boxed(ref Value val, IntPtr data);
 		static d_g_value_set_boxed g_value_set_boxed = FuncLoader.LoadFunction<d_g_value_set_boxed>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_boxed"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_double(ref Value val, double data);
 		static d_g_value_set_double g_value_set_double = FuncLoader.LoadFunction<d_g_value_set_double>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_double"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_float(ref Value val, float data);
 		static d_g_value_set_float g_value_set_float = FuncLoader.LoadFunction<d_g_value_set_float>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_float"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_int(ref Value val, int data);
 		static d_g_value_set_int g_value_set_int = FuncLoader.LoadFunction<d_g_value_set_int>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_int"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_int64(ref Value val, long data);
 		static d_g_value_set_int64 g_value_set_int64 = FuncLoader.LoadFunction<d_g_value_set_int64>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_int64"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_long(ref Value val, IntPtr data);
 		static d_g_value_set_long g_value_set_long = FuncLoader.LoadFunction<d_g_value_set_long>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_long"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_long2(ref Value val, int data);
 		static d_g_value_set_long2 g_value_set_long2 = FuncLoader.LoadFunction<d_g_value_set_long2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_long"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_uint64(ref Value val, ulong data);
 		static d_g_value_set_uint64 g_value_set_uint64 = FuncLoader.LoadFunction<d_g_value_set_uint64>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_uint64"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_object(ref Value val, IntPtr data);
 		static d_g_value_set_object g_value_set_object = FuncLoader.LoadFunction<d_g_value_set_object>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_object"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_param(ref Value val, IntPtr data);
 		static d_g_value_set_param g_value_set_param = FuncLoader.LoadFunction<d_g_value_set_param>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_param"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_pointer(ref Value val, IntPtr data);
 		static d_g_value_set_pointer g_value_set_pointer = FuncLoader.LoadFunction<d_g_value_set_pointer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_pointer"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_string(ref Value val, IntPtr data);
 		static d_g_value_set_string g_value_set_string = FuncLoader.LoadFunction<d_g_value_set_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_string"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_uint(ref Value val, uint data);
 		static d_g_value_set_uint g_value_set_uint = FuncLoader.LoadFunction<d_g_value_set_uint>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_uint"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_ulong(ref Value val, UIntPtr data);
 		static d_g_value_set_ulong g_value_set_ulong = FuncLoader.LoadFunction<d_g_value_set_ulong>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_ulong"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_ulong2(ref Value val, uint data);
 		static d_g_value_set_ulong2 g_value_set_ulong2 = FuncLoader.LoadFunction<d_g_value_set_ulong2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_ulong"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_enum(ref Value val, int data);
 		static d_g_value_set_enum g_value_set_enum = FuncLoader.LoadFunction<d_g_value_set_enum>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_enum"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_flags(ref Value val, uint data);
 		static d_g_value_set_flags g_value_set_flags = FuncLoader.LoadFunction<d_g_value_set_flags>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_flags"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_set_variant(ref Value val, IntPtr data);
 		static d_g_value_set_variant g_value_set_variant = FuncLoader.LoadFunction<d_g_value_set_variant>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_set_variant"));
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_value_get_boolean(ref Value val);
 		static d_g_value_get_boolean g_value_get_boolean = FuncLoader.LoadFunction<d_g_value_get_boolean>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_boolean"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate byte d_g_value_get_uchar(ref Value val);
 		static d_g_value_get_uchar g_value_get_uchar = FuncLoader.LoadFunction<d_g_value_get_uchar>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_uchar"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate sbyte d_g_value_get_char(ref Value val);
 		static d_g_value_get_char g_value_get_char = FuncLoader.LoadFunction<d_g_value_get_char>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_char"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_value_get_boxed(ref Value val);
 		static d_g_value_get_boxed g_value_get_boxed = FuncLoader.LoadFunction<d_g_value_get_boxed>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_boxed"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate double d_g_value_get_double(ref Value val);
 		static d_g_value_get_double g_value_get_double = FuncLoader.LoadFunction<d_g_value_get_double>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_double"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate float d_g_value_get_float(ref Value val);
 		static d_g_value_get_float g_value_get_float = FuncLoader.LoadFunction<d_g_value_get_float>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_float"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_value_get_int(ref Value val);
 		static d_g_value_get_int g_value_get_int = FuncLoader.LoadFunction<d_g_value_get_int>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_int"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate long d_g_value_get_int64(ref Value val);
 		static d_g_value_get_int64 g_value_get_int64 = FuncLoader.LoadFunction<d_g_value_get_int64>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_int64"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_value_get_long(ref Value val);
 		static d_g_value_get_long g_value_get_long = FuncLoader.LoadFunction<d_g_value_get_long>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_long"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_value_get_long_as_int(ref Value val);
 		static d_g_value_get_long_as_int g_value_get_long_as_int = FuncLoader.LoadFunction<d_g_value_get_long_as_int>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_long"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate ulong d_g_value_get_uint64(ref Value val);
 		static d_g_value_get_uint64 g_value_get_uint64 = FuncLoader.LoadFunction<d_g_value_get_uint64>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_uint64"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate UIntPtr d_g_value_get_ulong(ref Value val);
 		static d_g_value_get_ulong g_value_get_ulong = FuncLoader.LoadFunction<d_g_value_get_ulong>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_ulong"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_value_get_ulong_as_uint(ref Value val);
 		static d_g_value_get_ulong_as_uint g_value_get_ulong_as_uint = FuncLoader.LoadFunction<d_g_value_get_ulong_as_uint>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_ulong"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_value_get_object(ref Value val);
 		static d_g_value_get_object g_value_get_object = FuncLoader.LoadFunction<d_g_value_get_object>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_object"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_value_get_param(ref Value val);
 		static d_g_value_get_param g_value_get_param = FuncLoader.LoadFunction<d_g_value_get_param>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_param"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_value_get_pointer(ref Value val);
 		static d_g_value_get_pointer g_value_get_pointer = FuncLoader.LoadFunction<d_g_value_get_pointer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_pointer"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_value_get_string(ref Value val);
 		static d_g_value_get_string g_value_get_string = FuncLoader.LoadFunction<d_g_value_get_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_string"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_value_get_uint(ref Value val);
 		static d_g_value_get_uint g_value_get_uint = FuncLoader.LoadFunction<d_g_value_get_uint>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_uint"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_value_get_enum(ref Value val);
 		static d_g_value_get_enum g_value_get_enum = FuncLoader.LoadFunction<d_g_value_get_enum>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_enum"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_value_get_flags(ref Value val);
 		static d_g_value_get_flags g_value_get_flags = FuncLoader.LoadFunction<d_g_value_get_flags>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_flags"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_strv_get_type();
 		static d_g_strv_get_type g_strv_get_type = FuncLoader.LoadFunction<d_g_strv_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_strv_get_type"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_value_get_variant(ref Value val);
 		static d_g_value_get_variant g_value_get_variant = FuncLoader.LoadFunction<d_g_value_get_variant>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_get_variant"));
 	}
 }
+

Source/Libs/GLibSharp/ValueArray.cs

@@ -32,7 +32,7 @@ namespace GLib {
 
 		static private IList<IntPtr> PendingFrees = new List<IntPtr> ();
 		static private bool idle_queued = false;
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_value_array_new(uint n_preallocs);
 		static d_g_value_array_new g_value_array_new = FuncLoader.LoadFunction<d_g_value_array_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_array_new"));
 
@@ -57,7 +57,7 @@ namespace GLib {
 			Dispose (true);
 			GC.SuppressFinalize (this);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_array_free(IntPtr raw);
 		static d_g_value_array_free g_value_array_free = FuncLoader.LoadFunction<d_g_value_array_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_array_free"));
 
@@ -115,7 +115,7 @@ namespace GLib {
 		public IntPtr ArrayPtr {
 			get { return Native.values; }
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_array_append(IntPtr raw, ref GLib.Value val);
 		static d_g_value_array_append g_value_array_append = FuncLoader.LoadFunction<d_g_value_array_append>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_array_append"));
 
@@ -123,7 +123,7 @@ namespace GLib {
 		{
 			g_value_array_append (Handle, ref val);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_array_insert(IntPtr raw, uint idx, ref GLib.Value val);
 		static d_g_value_array_insert g_value_array_insert = FuncLoader.LoadFunction<d_g_value_array_insert>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_array_insert"));
 
@@ -131,7 +131,7 @@ namespace GLib {
 		{
 			g_value_array_insert (Handle, idx, ref val);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_array_prepend(IntPtr raw, ref GLib.Value val);
 		static d_g_value_array_prepend g_value_array_prepend = FuncLoader.LoadFunction<d_g_value_array_prepend>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_array_prepend"));
 
@@ -139,7 +139,7 @@ namespace GLib {
 		{
 			g_value_array_prepend (Handle, ref val);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_value_array_remove(IntPtr raw, uint idx);
 		static d_g_value_array_remove g_value_array_remove = FuncLoader.LoadFunction<d_g_value_array_remove>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_array_remove"));
 
@@ -152,7 +152,7 @@ namespace GLib {
 		public int Count {
 			get { return (int) Native.n_values; }
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_value_array_get_nth(IntPtr raw, uint idx);
 		static d_g_value_array_get_nth g_value_array_get_nth = FuncLoader.LoadFunction<d_g_value_array_get_nth>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_array_get_nth"));
 
@@ -226,7 +226,7 @@ namespace GLib {
 		{
 			return new ListEnumerator (this);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_value_array_copy(IntPtr raw);
 		static d_g_value_array_copy g_value_array_copy = FuncLoader.LoadFunction<d_g_value_array_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_array_copy"));
 
@@ -235,7 +235,7 @@ namespace GLib {
 		{
 			return new ValueArray (g_value_array_copy (Handle));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_value_array_get_type();
 		static d_g_value_array_get_type g_value_array_get_type = FuncLoader.LoadFunction<d_g_value_array_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_value_array_get_type"));
 
@@ -246,3 +246,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GLibSharp/Variant.cs

@@ -37,7 +37,7 @@ namespace GLib {
 		{
 			Dispose (true);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_variant_unref(IntPtr handle);
 		static d_g_variant_unref g_variant_unref = FuncLoader.LoadFunction<d_g_variant_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_unref"));
 
@@ -51,7 +51,7 @@ namespace GLib {
 			if (disposing)
 				GC.SuppressFinalize (this);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_ref_sink(IntPtr handle);
 		static d_g_variant_ref_sink g_variant_ref_sink = FuncLoader.LoadFunction<d_g_variant_ref_sink>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_ref_sink"));
 
@@ -59,7 +59,7 @@ namespace GLib {
 		{
 			this.handle = g_variant_ref_sink (handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_get_type(IntPtr val);
 		static d_g_variant_get_type g_variant_get_type = FuncLoader.LoadFunction<d_g_variant_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_type"));
 
@@ -71,59 +71,59 @@ namespace GLib {
 				return type;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_variant(IntPtr val);
 		static d_g_variant_new_variant g_variant_new_variant = FuncLoader.LoadFunction<d_g_variant_new_variant>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_variant"));
 
 		public static Variant NewVariant (Variant val) {
 			return new Variant (g_variant_new_variant (val.Handle));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_boolean(bool val);
 		static d_g_variant_new_boolean g_variant_new_boolean = FuncLoader.LoadFunction<d_g_variant_new_boolean>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_boolean"));
 
 		public Variant (bool val) : this (g_variant_new_boolean (val)) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_byte(byte val);
 		static d_g_variant_new_byte g_variant_new_byte = FuncLoader.LoadFunction<d_g_variant_new_byte>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_byte"));
 
 		public Variant (byte val) : this (g_variant_new_byte (val)) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_int16(short val);
 		static d_g_variant_new_int16 g_variant_new_int16 = FuncLoader.LoadFunction<d_g_variant_new_int16>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_int16"));
 
 		public Variant (short val) : this (g_variant_new_int16 (val)) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_uint16(ushort val);
 		static d_g_variant_new_uint16 g_variant_new_uint16 = FuncLoader.LoadFunction<d_g_variant_new_uint16>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_uint16"));
 
 		public Variant (ushort val) : this (g_variant_new_uint16 (val)) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_int32(int val);
 		static d_g_variant_new_int32 g_variant_new_int32 = FuncLoader.LoadFunction<d_g_variant_new_int32>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_int32"));
 
 		public Variant (int val) : this (g_variant_new_int32 (val)) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_uint32(uint val);
 		static d_g_variant_new_uint32 g_variant_new_uint32 = FuncLoader.LoadFunction<d_g_variant_new_uint32>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_uint32"));
 
 		public Variant (uint val) : this (g_variant_new_uint32 (val)) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_int64(long val);
 		static d_g_variant_new_int64 g_variant_new_int64 = FuncLoader.LoadFunction<d_g_variant_new_int64>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_int64"));
 
 		public Variant (long val) : this (g_variant_new_int64 (val)) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_uint64(ulong val);
 		static d_g_variant_new_uint64 g_variant_new_uint64 = FuncLoader.LoadFunction<d_g_variant_new_uint64>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_uint64"));
 
 		public Variant (ulong val) : this (g_variant_new_uint64 (val)) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_double(double val);
 		static d_g_variant_new_double g_variant_new_double = FuncLoader.LoadFunction<d_g_variant_new_double>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_double"));
 
 		public Variant (double val) : this (g_variant_new_double (val)) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_string(IntPtr val);
 		static d_g_variant_new_string g_variant_new_string = FuncLoader.LoadFunction<d_g_variant_new_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_string"));
 
@@ -133,7 +133,7 @@ namespace GLib {
 			handle = g_variant_ref_sink (g_variant_new_string (native_val));
 			Marshaller.Free (native_val);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_strv(IntPtr[] strv, IntPtr length);
 		static d_g_variant_new_strv g_variant_new_strv = FuncLoader.LoadFunction<d_g_variant_new_strv>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_strv"));
 
@@ -143,7 +143,7 @@ namespace GLib {
 			handle = g_variant_ref_sink (g_variant_new_strv (native, new IntPtr ((long) strv.Length)));
 			Marshaller.Free (native);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_tuple(IntPtr[] children, UIntPtr n_children);
 		static d_g_variant_new_tuple g_variant_new_tuple = FuncLoader.LoadFunction<d_g_variant_new_tuple>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_tuple"));
 
@@ -158,7 +158,7 @@ namespace GLib {
 
 			return new Variant (g_variant_new_tuple (native, new UIntPtr ((ulong) children.Length)));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_array(IntPtr child_type, IntPtr[] children, UIntPtr n_children);
 		static d_g_variant_new_array g_variant_new_array = FuncLoader.LoadFunction<d_g_variant_new_array>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_array"));
 
@@ -188,7 +188,7 @@ namespace GLib {
 			return new Variant (g_variant_new_array (type == null ? (IntPtr) null : type.Handle,
 			                                         native, new UIntPtr ((ulong) children.Length)));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_new_dict_entry(IntPtr k, IntPtr v);
 		static d_g_variant_new_dict_entry g_variant_new_dict_entry = FuncLoader.LoadFunction<d_g_variant_new_dict_entry>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_new_dict_entry"));
 
@@ -209,7 +209,7 @@ namespace GLib {
 
 			handle = g_variant_ref_sink (NewArray (type, pairs.ToArray ()).Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_variant_get_boolean(IntPtr handle);
 		static d_g_variant_get_boolean g_variant_get_boolean = FuncLoader.LoadFunction<d_g_variant_get_boolean>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_boolean"));
 
@@ -217,7 +217,7 @@ namespace GLib {
 		{
 			return g_variant_get_boolean (val.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate byte d_g_variant_get_byte(IntPtr handle);
 		static d_g_variant_get_byte g_variant_get_byte = FuncLoader.LoadFunction<d_g_variant_get_byte>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_byte"));
 
@@ -225,7 +225,7 @@ namespace GLib {
 		{
 			return g_variant_get_byte (val.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate short d_g_variant_get_int16(IntPtr handle);
 		static d_g_variant_get_int16 g_variant_get_int16 = FuncLoader.LoadFunction<d_g_variant_get_int16>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_int16"));
 
@@ -233,7 +233,7 @@ namespace GLib {
 		{
 			return g_variant_get_int16 (val.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate ushort d_g_variant_get_uint16(IntPtr handle);
 		static d_g_variant_get_uint16 g_variant_get_uint16 = FuncLoader.LoadFunction<d_g_variant_get_uint16>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_uint16"));
 
@@ -241,7 +241,7 @@ namespace GLib {
 		{
 			return g_variant_get_uint16 (val.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_variant_get_int32(IntPtr handle);
 		static d_g_variant_get_int32 g_variant_get_int32 = FuncLoader.LoadFunction<d_g_variant_get_int32>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_int32"));
 
@@ -249,7 +249,7 @@ namespace GLib {
 		{
 			return g_variant_get_int32 (val.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_g_variant_get_uint32(IntPtr handle);
 		static d_g_variant_get_uint32 g_variant_get_uint32 = FuncLoader.LoadFunction<d_g_variant_get_uint32>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_uint32"));
 
@@ -257,7 +257,7 @@ namespace GLib {
 		{
 			return g_variant_get_uint32 (val.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate long d_g_variant_get_int64(IntPtr handle);
 		static d_g_variant_get_int64 g_variant_get_int64 = FuncLoader.LoadFunction<d_g_variant_get_int64>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_int64"));
 
@@ -265,7 +265,7 @@ namespace GLib {
 		{
 			return g_variant_get_int64 (val.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate ulong d_g_variant_get_uint64(IntPtr handle);
 		static d_g_variant_get_uint64 g_variant_get_uint64 = FuncLoader.LoadFunction<d_g_variant_get_uint64>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_uint64"));
 
@@ -273,7 +273,7 @@ namespace GLib {
 		{
 			return g_variant_get_uint64 (val.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate double d_g_variant_get_double(IntPtr handle);
 		static d_g_variant_get_double g_variant_get_double = FuncLoader.LoadFunction<d_g_variant_get_double>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_double"));
 
@@ -281,7 +281,7 @@ namespace GLib {
 		{
 			return g_variant_get_double (val.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_get_string(IntPtr handle, IntPtr length);
 		static d_g_variant_get_string g_variant_get_string = FuncLoader.LoadFunction<d_g_variant_get_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_string"));
 
@@ -290,7 +290,7 @@ namespace GLib {
 			IntPtr str = g_variant_get_string (val.Handle, IntPtr.Zero);
 			return GLib.Marshaller.Utf8PtrToString (str);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_print(IntPtr variant, bool type_annotate);
 		static d_g_variant_print g_variant_print = FuncLoader.LoadFunction<d_g_variant_print>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_print"));
 
@@ -299,10 +299,10 @@ namespace GLib {
 			IntPtr str = g_variant_print (handle, type_annotate);
 			return Marshaller.PtrToStringGFree (str);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_n_children(IntPtr handle);
 		static d_g_variant_n_children g_variant_n_children = FuncLoader.LoadFunction<d_g_variant_n_children>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_n_children"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_get_child_value(IntPtr handle, IntPtr index);
 		static d_g_variant_get_child_value g_variant_get_child_value = FuncLoader.LoadFunction<d_g_variant_get_child_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_child_value"));
 
@@ -319,7 +319,7 @@ namespace GLib {
 
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_get_variant(IntPtr handle);
 		static d_g_variant_get_variant g_variant_get_variant = FuncLoader.LoadFunction<d_g_variant_get_variant>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_get_variant"));
 
@@ -341,3 +341,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GLibSharp/VariantType.cs

@@ -20,7 +20,7 @@ using System.Runtime.InteropServices;
 namespace GLib {
 
 	public class VariantType : IDisposable {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_variant_type_string_is_valid(IntPtr type_string);
 		static d_g_variant_type_string_is_valid g_variant_type_string_is_valid = FuncLoader.LoadFunction<d_g_variant_type_string_is_valid>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_string_is_valid"));
 
@@ -49,7 +49,7 @@ namespace GLib {
 		{
 			Dispose (true);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_variant_type_free(IntPtr handle);
 		static d_g_variant_type_free g_variant_type_free = FuncLoader.LoadFunction<d_g_variant_type_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_free"));
 
@@ -63,7 +63,7 @@ namespace GLib {
 			if (disposing)
 				GC.SuppressFinalize (this);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_copy(IntPtr handle);
 		static d_g_variant_type_copy g_variant_type_copy = FuncLoader.LoadFunction<d_g_variant_type_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_copy"));
 
@@ -71,7 +71,7 @@ namespace GLib {
 		{
 			this.handle = g_variant_type_copy (handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_new(IntPtr type_name);
 		static d_g_variant_type_new g_variant_type_new = FuncLoader.LoadFunction<d_g_variant_type_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_new"));
 
@@ -86,7 +86,7 @@ namespace GLib {
 		{
 			return new VariantType (Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_variant_type_equal(IntPtr a, IntPtr b);
 		static d_g_variant_type_equal g_variant_type_equal = FuncLoader.LoadFunction<d_g_variant_type_equal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_equal"));
 
@@ -94,7 +94,7 @@ namespace GLib {
 		{
 			return (o is VariantType) && g_variant_type_equal (Handle, (o as VariantType).Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_variant_type_hash(IntPtr a);
 		static d_g_variant_type_hash g_variant_type_hash = FuncLoader.LoadFunction<d_g_variant_type_hash>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_hash"));
 
@@ -102,7 +102,7 @@ namespace GLib {
 		{
 			return g_variant_type_hash (Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_peek_string(IntPtr a);
 		static d_g_variant_type_peek_string g_variant_type_peek_string = FuncLoader.LoadFunction<d_g_variant_type_peek_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_peek_string"));
 
@@ -110,7 +110,7 @@ namespace GLib {
 		{
 			return Marshaller.Utf8PtrToString (g_variant_type_peek_string (Handle));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_variant_type_is_array(IntPtr type);
 		static d_g_variant_type_is_array g_variant_type_is_array = FuncLoader.LoadFunction<d_g_variant_type_is_array>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_is_array"));
 
@@ -118,56 +118,56 @@ namespace GLib {
 			get { return g_variant_type_is_array (Handle); }
 		}
 
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_variant_type_is_basic(IntPtr type);
 		static d_g_variant_type_is_basic g_variant_type_is_basic = FuncLoader.LoadFunction<d_g_variant_type_is_basic>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_is_basic"));
 
 		public bool IsBasic {
 			get { return g_variant_type_is_basic (Handle); }
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_variant_type_is_container(IntPtr type);
 		static d_g_variant_type_is_container g_variant_type_is_container = FuncLoader.LoadFunction<d_g_variant_type_is_container>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_is_container"));
 
 		public bool IsContainer {
 			get { return g_variant_type_is_container (Handle); }
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_variant_type_is_definite(IntPtr type);
 		static d_g_variant_type_is_definite g_variant_type_is_definite = FuncLoader.LoadFunction<d_g_variant_type_is_definite>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_is_definite"));
 
 		public bool IsDefinite {
 			get { return g_variant_type_is_definite (Handle); }
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_variant_type_is_dict_entry(IntPtr type);
 		static d_g_variant_type_is_dict_entry g_variant_type_is_dict_entry = FuncLoader.LoadFunction<d_g_variant_type_is_dict_entry>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_is_dict_entry"));
 
 		public bool IsDictionaryEntry {
 			get { return g_variant_type_is_dict_entry (Handle); }
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_variant_type_is_maybe(IntPtr type);
 		static d_g_variant_type_is_maybe g_variant_type_is_maybe = FuncLoader.LoadFunction<d_g_variant_type_is_maybe>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_is_maybe"));
 
 		public bool IsMaybe {
 			get { return g_variant_type_is_maybe (Handle); }
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_variant_type_is_tuple(IntPtr type);
 		static d_g_variant_type_is_tuple g_variant_type_is_tuple = FuncLoader.LoadFunction<d_g_variant_type_is_tuple>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_is_tuple"));
 
 		public bool IsTuple {
 			get { return g_variant_type_is_tuple (Handle); }
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_variant_type_is_variant(IntPtr type);
 		static d_g_variant_type_is_variant g_variant_type_is_variant = FuncLoader.LoadFunction<d_g_variant_type_is_variant>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_is_variant"));
 
 		public bool IsVariant {
 			get { return g_variant_type_is_variant (Handle); }
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_g_variant_type_is_subtype_of(IntPtr type, IntPtr supertype);
 		static d_g_variant_type_is_subtype_of g_variant_type_is_subtype_of = FuncLoader.LoadFunction<d_g_variant_type_is_subtype_of>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_is_subtype_of"));
 
@@ -175,7 +175,7 @@ namespace GLib {
 		{
 			return g_variant_type_is_subtype_of (Handle, supertype == null ? IntPtr.Zero : supertype.Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_element(IntPtr type);
 		static d_g_variant_type_element g_variant_type_element = FuncLoader.LoadFunction<d_g_variant_type_element>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_element"));
 
@@ -183,7 +183,7 @@ namespace GLib {
 		{
 			return new VariantType (g_variant_type_element (Handle));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_first(IntPtr type);
 		static d_g_variant_type_first g_variant_type_first = FuncLoader.LoadFunction<d_g_variant_type_first>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_first"));
 
@@ -191,7 +191,7 @@ namespace GLib {
 		{
 			return new VariantType (g_variant_type_first (Handle));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_next(IntPtr type);
 		static d_g_variant_type_next g_variant_type_next = FuncLoader.LoadFunction<d_g_variant_type_next>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_next"));
 
@@ -199,7 +199,7 @@ namespace GLib {
 		{
 			return new VariantType (g_variant_type_next (Handle));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_n_items(IntPtr type);
 		static d_g_variant_type_n_items g_variant_type_n_items = FuncLoader.LoadFunction<d_g_variant_type_n_items>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_n_items"));
 
@@ -207,7 +207,7 @@ namespace GLib {
 		{
 			return g_variant_type_n_items (Handle).ToInt64 ();
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_key(IntPtr type);
 		static d_g_variant_type_key g_variant_type_key = FuncLoader.LoadFunction<d_g_variant_type_key>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_key"));
 
@@ -215,7 +215,7 @@ namespace GLib {
 		{
 			return new VariantType (g_variant_type_key (Handle));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_value(IntPtr type);
 		static d_g_variant_type_value g_variant_type_value = FuncLoader.LoadFunction<d_g_variant_type_value>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_value"));
 
@@ -223,7 +223,7 @@ namespace GLib {
 		{
 			return new VariantType (g_variant_type_value (Handle));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_new_array(IntPtr element);
 		static d_g_variant_type_new_array g_variant_type_new_array = FuncLoader.LoadFunction<d_g_variant_type_new_array>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_new_array"));
 
@@ -233,7 +233,7 @@ namespace GLib {
 			result.handle = g_variant_type_new_array (element == null ? IntPtr.Zero : element.Handle);
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_new_dict_entry(IntPtr key, IntPtr value);
 		static d_g_variant_type_new_dict_entry g_variant_type_new_dict_entry = FuncLoader.LoadFunction<d_g_variant_type_new_dict_entry>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_new_dict_entry"));
 
@@ -243,7 +243,7 @@ namespace GLib {
 			result.handle = g_variant_type_new_dict_entry (key == null ? IntPtr.Zero : key.Handle, value == null ? IntPtr.Zero : value.Handle);
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_new_maybe(IntPtr element);
 		static d_g_variant_type_new_maybe g_variant_type_new_maybe = FuncLoader.LoadFunction<d_g_variant_type_new_maybe>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_new_maybe"));
 
@@ -253,7 +253,7 @@ namespace GLib {
 			result.handle = g_variant_type_new_maybe (element == null ? IntPtr.Zero : element.Handle);
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_variant_type_new_tuple(IntPtr[] items, int n_items);
 		static d_g_variant_type_new_tuple g_variant_type_new_tuple = FuncLoader.LoadFunction<d_g_variant_type_new_tuple>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GLib), "g_variant_type_new_tuple"));
 
@@ -295,3 +295,4 @@ namespace GLib {
 		public static VariantType ByteStringArray = new VariantType ("aay");
 	}
 }
+

Source/Libs/GdkSharp/Color.cs

@@ -34,7 +34,7 @@ namespace Gdk {
 			Blue = (ushort) (b << 8 | b);
 			Pixel = 0;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_gdk_color_hash(ref Gdk.Color raw);
 		static d_gdk_color_hash gdk_color_hash = FuncLoader.LoadFunction<d_gdk_color_hash>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_color_hash"));
 
@@ -44,3 +44,4 @@ namespace Gdk {
 	}
 }
 
+

Source/Libs/GdkSharp/Device.cs

@@ -24,10 +24,10 @@ namespace Gdk {
 	using System.Runtime.InteropServices;
 
 	public partial class Device {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_device_free_history(IntPtr events, int n_events);
 		static d_gdk_device_free_history gdk_device_free_history = FuncLoader.LoadFunction<d_gdk_device_free_history>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_free_history"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gdk_device_get_history(IntPtr device, IntPtr window, uint start, uint stop, out IntPtr events, out int n_events);
 		static d_gdk_device_get_history gdk_device_get_history = FuncLoader.LoadFunction<d_gdk_device_get_history>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_device_get_history"));
 
@@ -50,3 +50,4 @@ namespace Gdk {
 	}
 }
 
+

Source/Libs/GdkSharp/Display.cs

@@ -25,7 +25,7 @@ namespace Gdk {
 	using System.Runtime.InteropServices;
 
 	public partial class Display {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_display_get_pointer(IntPtr raw, IntPtr screen, out int x, out int y, out int mask);
 		static d_gdk_display_get_pointer gdk_display_get_pointer = FuncLoader.LoadFunction<d_gdk_display_get_pointer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_get_pointer"));
 
@@ -35,7 +35,7 @@ namespace Gdk {
 			gdk_display_get_pointer(Handle, screen.Handle, out x, out y, out mask_as_int);
 			mask = (Gdk.ModifierType) mask_as_int;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_display_get_pointer2(IntPtr raw, out IntPtr screen, out int x, out int y, out int mask);
 		static d_gdk_display_get_pointer2 gdk_display_get_pointer2 = FuncLoader.LoadFunction<d_gdk_display_get_pointer2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_get_pointer"));
 
@@ -65,7 +65,7 @@ namespace Gdk {
 			Gdk.ModifierType mod;
 			GetPointer (out screen, out x, out y, out mod);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_display_list_devices(IntPtr raw);
 		static d_gdk_display_list_devices gdk_display_list_devices = FuncLoader.LoadFunction<d_gdk_display_list_devices>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_list_devices"));
 
@@ -83,3 +83,4 @@ namespace Gdk {
 	}
 }
 
+

Source/Libs/GdkSharp/DisplayManager.cs

@@ -24,7 +24,7 @@ namespace Gdk {
 	using System.Runtime.InteropServices;
 
 	public partial class DisplayManager {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_display_manager_list_displays(IntPtr raw);
 		static d_gdk_display_manager_list_displays gdk_display_manager_list_displays = FuncLoader.LoadFunction<d_gdk_display_manager_list_displays>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_display_manager_list_displays"));
 
@@ -42,3 +42,4 @@ namespace Gdk {
 	}
 }
 
+

Source/Libs/GdkSharp/Event.cs

@@ -38,7 +38,7 @@ namespace Gdk {
 		public IntPtr Handle {
 			get { return raw; }
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_event_get_type();
 		static d_gdk_event_get_type gdk_event_get_type = FuncLoader.LoadFunction<d_gdk_event_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_event_get_type"));
 
@@ -154,3 +154,4 @@ namespace Gdk {
 	}
 }
 
+

Source/Libs/GdkSharp/Global.cs

@@ -25,7 +25,7 @@ namespace Gdk {
 	using System.Runtime.InteropServices;
 
 	public partial class Global {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_list_visuals();
 		static d_gdk_list_visuals gdk_list_visuals = FuncLoader.LoadFunction<d_gdk_list_visuals>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_list_visuals"));
 
@@ -104,7 +104,7 @@ namespace Gdk {
 				return workareas;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gdk_init_check(ref int argc, ref IntPtr argv);
 		static d_gdk_init_check gdk_init_check = FuncLoader.LoadFunction<d_gdk_init_check>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_init_check"));
 
@@ -118,7 +118,7 @@ namespace Gdk {
 			argv = a.GetArgs (argc);
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_parse_args(ref int argc, ref IntPtr argv);
 		static d_gdk_parse_args gdk_parse_args = FuncLoader.LoadFunction<d_gdk_parse_args>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_parse_args"));
 
@@ -131,7 +131,7 @@ namespace Gdk {
 			gdk_parse_args (ref argc, ref buf);
 			argv = a.GetArgs (argc);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_query_depths(out IntPtr depths, out int n_depths);
 		static d_gdk_query_depths gdk_query_depths = FuncLoader.LoadFunction<d_gdk_query_depths>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_query_depths"));
 
@@ -144,6 +144,7 @@ namespace Gdk {
 			Marshal.Copy (ptr, result, 0, count);
 			return result;
 		}
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_query_visual_types(out IntPtr types, out int n_types);
 		static d_gdk_query_visual_types gdk_query_visual_types = FuncLoader.LoadFunction<d_gdk_query_visual_types>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_query_visual_types"));
 
@@ -162,3 +163,4 @@ namespace Gdk {
 	}
 }
 
+

Source/Libs/GdkSharp/Keymap.cs

@@ -25,7 +25,7 @@ namespace Gdk {
 	using System.Runtime.InteropServices;
 
 	public partial class Keymap {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gdk_keymap_get_entries_for_keycode(IntPtr raw, uint hardware_keycode, out IntPtr keys, out IntPtr keyvals, out int n_entries);
 		static d_gdk_keymap_get_entries_for_keycode gdk_keymap_get_entries_for_keycode = FuncLoader.LoadFunction<d_gdk_keymap_get_entries_for_keycode>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_get_entries_for_keycode"));
 
@@ -50,7 +50,7 @@ namespace Gdk {
 				keyvals = new uint [0];
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gdk_keymap_get_entries_for_keyval(IntPtr raw, uint keyval, out IntPtr keys, out int n_keys);
 		static d_gdk_keymap_get_entries_for_keyval gdk_keymap_get_entries_for_keyval = FuncLoader.LoadFunction<d_gdk_keymap_get_entries_for_keyval>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_keymap_get_entries_for_keyval"));
 
@@ -72,3 +72,4 @@ namespace Gdk {
 	}
 }
 
+

Source/Libs/GdkSharp/Pixbuf.cs

@@ -85,7 +85,7 @@ namespace Gdk {
 		{
 			return new Pixbuf (System.Reflection.Assembly.GetCallingAssembly (), resource);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_pixbuf_scale_simple(IntPtr raw, int dest_width, int dest_height, int interp_type);
 		static d_gdk_pixbuf_scale_simple gdk_pixbuf_scale_simple = FuncLoader.LoadFunction<d_gdk_pixbuf_scale_simple>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_pixbuf_scale_simple"));
 
@@ -94,7 +94,7 @@ namespace Gdk {
 			Gdk.Pixbuf ret = (Gdk.Pixbuf) GLib.Object.GetObject(raw_ret, true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_pixbuf_composite_color_simple(IntPtr raw, int dest_width, int dest_height, int interp_type, int overall_alpha, int check_size, uint color1, uint color2);
 		static d_gdk_pixbuf_composite_color_simple gdk_pixbuf_composite_color_simple = FuncLoader.LoadFunction<d_gdk_pixbuf_composite_color_simple>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_pixbuf_composite_color_simple"));
 
@@ -103,7 +103,7 @@ namespace Gdk {
 			Gdk.Pixbuf ret = (Gdk.Pixbuf) GLib.Object.GetObject(raw_ret, true);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_pixbuf_add_alpha(IntPtr raw, bool substitute_color, byte r, byte g, byte b);
 		static d_gdk_pixbuf_add_alpha gdk_pixbuf_add_alpha = FuncLoader.LoadFunction<d_gdk_pixbuf_add_alpha>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_pixbuf_add_alpha"));
 
@@ -145,7 +145,7 @@ namespace Gdk {
 				}
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_pixbuf_new_from_data(byte[] data, int colorspace, bool has_alpha, int bits_per_sample, int width, int height, int rowstride, DestroyHelper.NativeDelegate destroy_fn, IntPtr destroy_fn_data);
 		static d_gdk_pixbuf_new_from_data gdk_pixbuf_new_from_data = FuncLoader.LoadFunction<d_gdk_pixbuf_new_from_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_pixbuf_new_from_data"));
 
@@ -174,7 +174,7 @@ namespace Gdk {
 			if (error != IntPtr.Zero) throw new GLib.GException (error);
 		}
 		*/
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_pixbuf_new_from_inline(int len, IntPtr data, bool copy_pixels, out IntPtr error);
 		static d_gdk_pixbuf_new_from_inline gdk_pixbuf_new_from_inline = FuncLoader.LoadFunction<d_gdk_pixbuf_new_from_inline>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_pixbuf_new_from_inline"));
 
@@ -198,6 +198,7 @@ namespace Gdk {
 //
 // the 'Pixels' property
 //
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_pixbuf_get_pixels(IntPtr raw);
 		static d_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels = FuncLoader.LoadFunction<d_gdk_pixbuf_get_pixels>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_pixbuf_get_pixels"));
 
@@ -207,7 +208,7 @@ namespace Gdk {
                 		return ret;
                 	}
                 }
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_pixbuf_get_formats();
 		static d_gdk_pixbuf_get_formats gdk_pixbuf_get_formats = FuncLoader.LoadFunction<d_gdk_pixbuf_get_formats>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_pixbuf_get_formats"));
 
@@ -223,7 +224,7 @@ namespace Gdk {
 				return result;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gdk_pixbuf_save(IntPtr raw, IntPtr filename, IntPtr type, out IntPtr error, IntPtr dummy);
 		static d_gdk_pixbuf_save gdk_pixbuf_save = FuncLoader.LoadFunction<d_gdk_pixbuf_save>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_pixbuf_save"));
 
@@ -237,7 +238,7 @@ namespace Gdk {
 			if (error != IntPtr.Zero) throw new GLib.GException (error);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gdk_pixbuf_save_to_bufferv(IntPtr raw, out IntPtr buffer, out IntPtr buffer_size, IntPtr type, IntPtr[] option_keys, IntPtr[] option_values, out IntPtr error);
 		static d_gdk_pixbuf_save_to_bufferv gdk_pixbuf_save_to_bufferv = FuncLoader.LoadFunction<d_gdk_pixbuf_save_to_bufferv>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_pixbuf_save_to_bufferv"));
 
@@ -285,7 +286,7 @@ namespace Gdk {
 			GLib.Marshaller.Free (buffer);
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gdk_pixbuf_save_to_callbackv(IntPtr raw, GdkSharp.PixbufSaveFuncNative save_func, IntPtr user_data, IntPtr type, IntPtr[] option_keys, IntPtr[] option_values, out IntPtr error);
 		static d_gdk_pixbuf_save_to_callbackv gdk_pixbuf_save_to_callbackv = FuncLoader.LoadFunction<d_gdk_pixbuf_save_to_callbackv>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_pixbuf_save_to_callbackv"));
 
@@ -309,7 +310,7 @@ namespace Gdk {
 			if (!saved)
 				throw new GLib.GException (error);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gdk_pixbuf_savev(IntPtr raw, IntPtr filename, IntPtr type, IntPtr[] option_keys, IntPtr[] option_values, out IntPtr error);
 		static d_gdk_pixbuf_savev gdk_pixbuf_savev = FuncLoader.LoadFunction<d_gdk_pixbuf_savev>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_pixbuf_savev"));
 
@@ -332,3 +333,4 @@ namespace Gdk {
 	}
 }
 
+

Source/Libs/GdkSharp/PixbufLoader.cs

@@ -27,7 +27,7 @@ namespace Gdk {
 	using System.Runtime.InteropServices;
 
 	public partial class PixbufLoader {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_object_ref(IntPtr handle);
 		static d_g_object_ref g_object_ref = FuncLoader.LoadFunction<d_g_object_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_ref"));
 
@@ -151,3 +151,4 @@ namespace Gdk {
 	}
 }
 
+

Source/Libs/GdkSharp/Pixdata.cs

@@ -22,7 +22,7 @@ namespace Gdk {
 	using System.Runtime.InteropServices;
 
 	public partial struct Pixdata {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_pixdata_serialize(ref Gdk.Pixdata raw, out uint len);
 		static d_gdk_pixdata_serialize gdk_pixdata_serialize = FuncLoader.LoadFunction<d_gdk_pixdata_serialize>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GdkPixbuf), "gdk_pixdata_serialize"));
 	
@@ -38,3 +38,4 @@ namespace Gdk {
 	}
 }
 
+

Source/Libs/GdkSharp/Property.cs

@@ -25,7 +25,7 @@ namespace Gdk {
 	using System.Runtime.InteropServices;
 
 	public partial class Property {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_property_change2(IntPtr window, IntPtr property, IntPtr type, int format, int mode, out byte data, int nelements);
 		static d_gdk_property_change2 gdk_property_change2 = FuncLoader.LoadFunction<d_gdk_property_change2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_property_change"));
 
@@ -35,7 +35,7 @@ namespace Gdk {
 			gdk_property_change2(window == null ? IntPtr.Zero : window.Handle, property == null ? IntPtr.Zero : property.Handle, type == null ? IntPtr.Zero : type.Handle, format, (int) mode, out data, nelements);
 			return data;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gdk_property_get(IntPtr window, IntPtr property, IntPtr type, UIntPtr offset, UIntPtr length, bool pdelete, out IntPtr actual_property_type, out int actual_format, out int actual_length, out IntPtr data);
 		static d_gdk_property_get gdk_property_get = FuncLoader.LoadFunction<d_gdk_property_get>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_property_get"));
 
@@ -164,3 +164,4 @@ namespace Gdk {
 	}
 }
 
+

Source/Libs/GdkSharp/Rectangle.cs

@@ -218,7 +218,7 @@ namespace Gdk {
 		{
 			return Offset (rect, dr.X, dr.Y);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_rectangle_get_type();
 		static d_gdk_rectangle_get_type gdk_rectangle_get_type = FuncLoader.LoadFunction<d_gdk_rectangle_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_rectangle_get_type"));
 
@@ -229,7 +229,7 @@ namespace Gdk {
 				return ret;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_rectangle_union(ref Rectangle src1, ref Rectangle src2, out Rectangle dest);
 		static d_gdk_rectangle_union gdk_rectangle_union = FuncLoader.LoadFunction<d_gdk_rectangle_union>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_rectangle_union"));
 
@@ -239,7 +239,7 @@ namespace Gdk {
 			gdk_rectangle_union (ref this, ref src, out dest);
 			return dest;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gdk_rectangle_intersect(ref Rectangle src1, ref Rectangle src2, out Rectangle dest);
 		static d_gdk_rectangle_intersect gdk_rectangle_intersect = FuncLoader.LoadFunction<d_gdk_rectangle_intersect>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_rectangle_intersect"));
 
@@ -256,3 +256,4 @@ namespace Gdk {
 		public static Rectangle Zero;
 	}
 }
+

Source/Libs/GdkSharp/Screen.cs

@@ -24,7 +24,7 @@ namespace Gdk {
 	using System.Runtime.InteropServices;
 
 	public partial class Screen {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_screen_get_toplevel_windows(IntPtr raw);
 		static d_gdk_screen_get_toplevel_windows gdk_screen_get_toplevel_windows = FuncLoader.LoadFunction<d_gdk_screen_get_toplevel_windows>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_screen_get_toplevel_windows"));
 
@@ -41,7 +41,7 @@ namespace Gdk {
 				return result;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_screen_list_visuals(IntPtr raw);
 		static d_gdk_screen_list_visuals gdk_screen_list_visuals = FuncLoader.LoadFunction<d_gdk_screen_list_visuals>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_screen_list_visuals"));
 
@@ -56,10 +56,10 @@ namespace Gdk {
 				result [i] = list [i] as Visual;
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_screen_get_font_options(IntPtr raw);
 		static d_gdk_screen_get_font_options gdk_screen_get_font_options = FuncLoader.LoadFunction<d_gdk_screen_get_font_options>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_screen_get_font_options"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_screen_set_font_options(IntPtr raw, IntPtr options);
 		static d_gdk_screen_set_font_options gdk_screen_set_font_options = FuncLoader.LoadFunction<d_gdk_screen_set_font_options>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_screen_set_font_options"));
 
@@ -79,3 +79,4 @@ namespace Gdk {
 	}
 }
 
+

Source/Libs/GdkSharp/TextProperty.cs

@@ -25,7 +25,7 @@ namespace Gdk {
 	using System.Runtime.InteropServices;
 
 	public class TextProperty {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_gdk_text_property_to_utf8_list_for_display(IntPtr display, IntPtr encoding, int format, byte[] text, int length, out IntPtr list);
 		static d_gdk_text_property_to_utf8_list_for_display gdk_text_property_to_utf8_list_for_display = FuncLoader.LoadFunction<d_gdk_text_property_to_utf8_list_for_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_text_property_to_utf8_list_for_display"));
 
@@ -47,3 +47,4 @@ namespace Gdk {
 		}
 	}
 }
+

Source/Libs/GdkSharp/Window.cs

@@ -31,10 +31,10 @@ namespace Gdk {
 	public partial class Window {
 
 		public Window (Gdk.Window parent, Gdk.WindowAttr attributes, Gdk.WindowAttributesType attributes_mask) : this (parent, attributes, (int)attributes_mask) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_window_get_background_pattern(IntPtr raw);
 		static d_gdk_window_get_background_pattern gdk_window_get_background_pattern = FuncLoader.LoadFunction<d_gdk_window_get_background_pattern>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_get_background_pattern"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_window_set_background_pattern(IntPtr raw, IntPtr pattern);
 		static d_gdk_window_set_background_pattern gdk_window_set_background_pattern = FuncLoader.LoadFunction<d_gdk_window_set_background_pattern>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_set_background_pattern"));
 
@@ -48,7 +48,7 @@ namespace Gdk {
 				gdk_window_set_background_pattern(Handle, (value == null) ? IntPtr.Zero : value.Handle);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gdk_window_get_children(IntPtr raw);
 		static d_gdk_window_get_children gdk_window_get_children = FuncLoader.LoadFunction<d_gdk_window_get_children>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_get_children"));
 
@@ -64,7 +64,7 @@ namespace Gdk {
 				return result;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_window_set_icon_list(IntPtr raw, IntPtr pixbufs);
 		static d_gdk_window_set_icon_list gdk_window_set_icon_list = FuncLoader.LoadFunction<d_gdk_window_set_icon_list>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_set_icon_list"));
 
@@ -76,10 +76,10 @@ namespace Gdk {
 				gdk_window_set_icon_list(Handle, list.Handle);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_object_ref(IntPtr raw);
 		static d_g_object_ref g_object_ref = FuncLoader.LoadFunction<d_g_object_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_ref"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_window_destroy(IntPtr raw);
 		static d_gdk_window_destroy gdk_window_destroy = FuncLoader.LoadFunction<d_gdk_window_destroy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_destroy"));
 
@@ -96,10 +96,10 @@ namespace Gdk {
 		public void MoveResize (Gdk.Rectangle rect) {
 			gdk_window_move_resize (Handle, rect.X, rect.Y, rect.Width, rect.Height);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_window_get_user_data(IntPtr raw, out IntPtr data);
 		static d_gdk_window_get_user_data gdk_window_get_user_data = FuncLoader.LoadFunction<d_gdk_window_get_user_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_get_user_data"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_window_set_user_data(IntPtr raw, IntPtr user_data);
 		static d_gdk_window_set_user_data gdk_window_set_user_data = FuncLoader.LoadFunction<d_gdk_window_set_user_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_set_user_data"));
 		public IntPtr UserData {
@@ -112,10 +112,10 @@ namespace Gdk {
 				gdk_window_set_user_data(Handle, value);
 			}
 		} 
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_window_add_filter(IntPtr handle, GdkSharp.FilterFuncNative wrapper, IntPtr data);
 		static d_gdk_window_add_filter gdk_window_add_filter = FuncLoader.LoadFunction<d_gdk_window_add_filter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_add_filter"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gdk_window_remove_filter(IntPtr handle, GdkSharp.FilterFuncNative wrapper, IntPtr data);
 		static d_gdk_window_remove_filter gdk_window_remove_filter = FuncLoader.LoadFunction<d_gdk_window_remove_filter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gdk), "gdk_window_remove_filter"));
 
@@ -189,3 +189,4 @@ namespace Gdk {
 #endif
 	}
 }
+

Source/Libs/GioSharp/AppInfoAdapter.cs

@@ -23,6 +23,7 @@ namespace GLib {
 	using System.Runtime.InteropServices;
 	
 	public partial class AppInfoAdapter {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_app_info_get_all();
 		static d_g_app_info_get_all g_app_info_get_all = FuncLoader.LoadFunction<d_g_app_info_get_all>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gio), "g_app_info_get_all"));
 
@@ -33,3 +34,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GioSharp/Application.cs

@@ -30,7 +30,7 @@ namespace GLib
 		public Application () : this (null, ApplicationFlags.None)
 		{
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_g_application_run(IntPtr raw, int argc, IntPtr argv);
 		static d_g_application_run g_application_run = FuncLoader.LoadFunction<d_g_application_run>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gio), "g_application_run"));
 
@@ -65,3 +65,4 @@ namespace GLib
 		}
 	}
 }
+

Source/Libs/GioSharp/FileAdapter.cs

@@ -37,6 +37,7 @@ namespace GLib {
 			return Delete (null);
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_file_get_uri(IntPtr raw);
 		static d_g_file_get_uri g_file_get_uri = FuncLoader.LoadFunction<d_g_file_get_uri>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gio), "g_file_get_uri"));
 		
@@ -49,3 +50,4 @@ namespace GLib {
 		}
 	}
 }
+

Source/Libs/GioSharp/FileFactory.cs

@@ -27,6 +27,7 @@ namespace GLib
 {
 	public class FileFactory
 	{
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_file_new_for_uri(string uri);
 		static d_g_file_new_for_uri g_file_new_for_uri = FuncLoader.LoadFunction<d_g_file_new_for_uri>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gio), "g_file_new_for_uri"));
 
@@ -39,7 +40,7 @@ namespace GLib
 		{
 			return GLib.FileAdapter.GetObject (g_file_new_for_uri (uri.ToString ()), false) as IFile;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_file_new_for_path(string path);
 		static d_g_file_new_for_path g_file_new_for_path = FuncLoader.LoadFunction<d_g_file_new_for_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gio), "g_file_new_for_path"));
 		
@@ -47,7 +48,7 @@ namespace GLib
 		{
 			return GLib.FileAdapter.GetObject (g_file_new_for_path (path), false) as IFile;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_g_file_new_for_commandline_arg(string arg);
 		static d_g_file_new_for_commandline_arg g_file_new_for_commandline_arg = FuncLoader.LoadFunction<d_g_file_new_for_commandline_arg>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gio), "g_file_new_for_commandline_arg"));
 
@@ -57,3 +58,4 @@ namespace GLib
 		}
 	}
 }
+

Source/Libs/GtkSharp/Accel.cs

@@ -24,7 +24,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class Accel {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_accel_map_save(IntPtr file_name);
 		static d_gtk_accel_map_save gtk_accel_map_save = FuncLoader.LoadFunction<d_gtk_accel_map_save>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_accel_map_save"));
 
@@ -34,7 +34,7 @@ namespace Gtk {
 			gtk_accel_map_save (native);
 			GLib.Marshaller.Free (native);
         }
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_accel_map_add_filter(IntPtr filter_pattern);
 		static d_gtk_accel_map_add_filter gtk_accel_map_add_filter = FuncLoader.LoadFunction<d_gtk_accel_map_add_filter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_accel_map_add_filter"));
 
@@ -44,7 +44,7 @@ namespace Gtk {
 			gtk_accel_map_add_filter (native);
 			GLib.Marshaller.Free (native);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_accel_map_foreach_unfiltered(IntPtr data, GtkSharp.AccelMapForeachNative foreach_func);
 		static d_gtk_accel_map_foreach_unfiltered gtk_accel_map_foreach_unfiltered = FuncLoader.LoadFunction<d_gtk_accel_map_foreach_unfiltered>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_accel_map_foreach_unfiltered"));
 
@@ -53,7 +53,7 @@ namespace Gtk {
 			GtkSharp.AccelMapForeachWrapper foreach_func_wrapper = new GtkSharp.AccelMapForeachWrapper (foreach_func);
 			gtk_accel_map_foreach_unfiltered(data, foreach_func_wrapper.NativeDelegate);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_accel_map_save_fd(int fd);
 		static d_gtk_accel_map_save_fd gtk_accel_map_save_fd = FuncLoader.LoadFunction<d_gtk_accel_map_save_fd>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_accel_map_save_fd"));
 
@@ -61,7 +61,7 @@ namespace Gtk {
 		public static void MapSaveFd(int fd) {
 			gtk_accel_map_save_fd(fd);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_accel_map_add_entry(IntPtr accel_path, uint accel_key, int accel_mods);
 		static d_gtk_accel_map_add_entry gtk_accel_map_add_entry = FuncLoader.LoadFunction<d_gtk_accel_map_add_entry>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_accel_map_add_entry"));
 
@@ -71,7 +71,7 @@ namespace Gtk {
 			gtk_accel_map_add_entry(native, accel_key, (int) accel_mods);
 			GLib.Marshaller.Free (native);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_accel_map_load_fd(int fd);
 		static d_gtk_accel_map_load_fd gtk_accel_map_load_fd = FuncLoader.LoadFunction<d_gtk_accel_map_load_fd>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_accel_map_load_fd"));
 
@@ -79,7 +79,7 @@ namespace Gtk {
 		public static void MapLoadFd(int fd) {
 			gtk_accel_map_load_fd(fd);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_accel_map_lookup_entry(IntPtr accel_path, ref Gtk.AccelKey key);
 		static d_gtk_accel_map_lookup_entry gtk_accel_map_lookup_entry = FuncLoader.LoadFunction<d_gtk_accel_map_lookup_entry>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_accel_map_lookup_entry"));
 
@@ -90,7 +90,7 @@ namespace Gtk {
 			GLib.Marshaller.Free (native);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_accel_map_change_entry(IntPtr accel_path, uint accel_key, int accel_mods, bool replace);
 		static d_gtk_accel_map_change_entry gtk_accel_map_change_entry = FuncLoader.LoadFunction<d_gtk_accel_map_change_entry>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_accel_map_change_entry"));
 
@@ -101,7 +101,7 @@ namespace Gtk {
 			GLib.Marshaller.Free (native);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_accel_map_load(IntPtr file_name);
 		static d_gtk_accel_map_load gtk_accel_map_load = FuncLoader.LoadFunction<d_gtk_accel_map_load>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_accel_map_load"));
 
@@ -111,7 +111,7 @@ namespace Gtk {
 			gtk_accel_map_load (native);
 			GLib.Marshaller.Free (native);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_accel_map_foreach(IntPtr data, GtkSharp.AccelMapForeachNative foreach_func);
 		static d_gtk_accel_map_foreach gtk_accel_map_foreach = FuncLoader.LoadFunction<d_gtk_accel_map_foreach>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_accel_map_foreach"));
 
@@ -120,7 +120,7 @@ namespace Gtk {
 			GtkSharp.AccelMapForeachWrapper foreach_func_wrapper = new GtkSharp.AccelMapForeachWrapper (foreach_func);
 			gtk_accel_map_foreach(data, foreach_func_wrapper.NativeDelegate);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_accel_groups_from_object(IntPtr obj);
 		static d_gtk_accel_groups_from_object gtk_accel_groups_from_object = FuncLoader.LoadFunction<d_gtk_accel_groups_from_object>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_accel_groups_from_object"));
 
@@ -137,3 +137,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Action.cs

@@ -27,7 +27,7 @@ namespace Gtk {
 
 		public Action (string name, string label) : this (name, label, null, null)
 		{}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_action_get_proxies(IntPtr raw);
 		static d_gtk_action_get_proxies gtk_action_get_proxies = FuncLoader.LoadFunction<d_gtk_action_get_proxies>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_action_get_proxies"));
 
@@ -43,3 +43,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/ActionGroup.cs

@@ -79,7 +79,7 @@ namespace Gtk {
 			if (changed != null)
 				actions[0].Changed += changed;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_action_group_list_actions(IntPtr raw);
 		static d_gtk_action_group_list_actions gtk_action_group_list_actions = FuncLoader.LoadFunction<d_gtk_action_group_list_actions>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_action_group_list_actions"));
 
@@ -93,3 +93,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Adjustment.cs

@@ -22,7 +22,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class Adjustment {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_adjustment_new(double value, double lower, double upper, double step_increment, double page_increment, double page_size);
 		static d_gtk_adjustment_new gtk_adjustment_new = FuncLoader.LoadFunction<d_gtk_adjustment_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_adjustment_new"));
 
@@ -41,10 +41,10 @@ namespace Gtk {
 
 			Raw = gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_freeze_notify(IntPtr inst);
 		static d_g_object_freeze_notify g_object_freeze_notify = FuncLoader.LoadFunction<d_g_object_freeze_notify>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_freeze_notify"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_g_object_thaw_notify(IntPtr inst);
 		static d_g_object_thaw_notify g_object_thaw_notify = FuncLoader.LoadFunction<d_g_object_thaw_notify>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GObject), "g_object_thaw_notify"));
 
@@ -63,3 +63,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Application.cs

@@ -31,9 +31,11 @@ namespace Gtk {
 		const int WS_EX_TOOLWINDOW = 0x00000080;
 		const int WS_OVERLAPPEDWINDOW = 0x00CF0000;
 
+        [UnmanagedFunctionPointer(CallingConvention.Winapi)]
 		delegate IntPtr d_Win32CreateWindow(int dwExStyle, string lpClassName, string lpWindowName,int dwStyle, int x, int y, int nWidth, int nHeight, IntPtr hWndParent, IntPtr hMenu, IntPtr hInstance, IntPtr lParam);
         static d_Win32CreateWindow Win32CreateWindow;
 
+        [UnmanagedFunctionPointer(CallingConvention.Winapi)]
 		delegate bool d_Win32DestroyWindow(IntPtr window);
         static d_Win32DestroyWindow Win32DestroyWindow;
 
@@ -58,10 +60,10 @@ namespace Gtk {
 				break;
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_init(ref int argc, ref IntPtr argv);
 		static d_gtk_init gtk_init = FuncLoader.LoadFunction<d_gtk_init>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_init"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_init_check(ref int argc, ref IntPtr argv);
 		static d_gtk_init_check gtk_init_check = FuncLoader.LoadFunction<d_gtk_init_check>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_init_check"));
 
@@ -127,7 +129,7 @@ namespace Gtk {
 		{
 			return do_init (progname, ref args, true);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_main();
 		static d_gtk_main gtk_main = FuncLoader.LoadFunction<d_gtk_main>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_main"));
 
@@ -135,7 +137,7 @@ namespace Gtk {
 		{
 			gtk_main ();
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_events_pending();
 		static d_gtk_events_pending gtk_events_pending = FuncLoader.LoadFunction<d_gtk_events_pending>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_events_pending"));
 
@@ -144,10 +146,10 @@ namespace Gtk {
 		{
 			return gtk_events_pending ();
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_main_iteration();
 		static d_gtk_main_iteration gtk_main_iteration = FuncLoader.LoadFunction<d_gtk_main_iteration>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_main_iteration"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_main_iteration_do(bool blocking);
 		static d_gtk_main_iteration_do gtk_main_iteration_do = FuncLoader.LoadFunction<d_gtk_main_iteration_do>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_main_iteration_do"));
 
@@ -161,6 +163,7 @@ namespace Gtk {
 			return gtk_main_iteration_do (blocking);
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_main_quit();
 		static d_gtk_main_quit gtk_main_quit = FuncLoader.LoadFunction<d_gtk_main_quit>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_main_quit"));
 
@@ -169,7 +172,7 @@ namespace Gtk {
 			gtk_main_quit ();
 		}
 
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_get_current_event();
 		static d_gtk_get_current_event gtk_get_current_event = FuncLoader.LoadFunction<d_gtk_get_current_event>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_get_current_event"));
 
@@ -220,3 +223,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Bin.cs

@@ -24,7 +24,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class Bin {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_bin_get_child(IntPtr raw);
 		static d_gtk_bin_get_child gtk_bin_get_child = FuncLoader.LoadFunction<d_gtk_bin_get_child>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_bin_get_child"));
 
@@ -46,3 +46,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Builder.cs

@@ -223,6 +223,7 @@ namespace Gtk {
 				this.handler_type = handler_type;		
 			}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_builder_connect_signals_full(IntPtr raw, GtkSharp.BuilderConnectFuncNative func, IntPtr user_data);
 		static d_gtk_builder_connect_signals_full gtk_builder_connect_signals_full = FuncLoader.LoadFunction<d_gtk_builder_connect_signals_full>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_builder_connect_signals_full"));
 		
@@ -426,3 +427,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Button.cs

@@ -24,7 +24,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class Button {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_button_new_from_stock(IntPtr stock_id);
 		static d_gtk_button_new_from_stock gtk_button_new_from_stock = FuncLoader.LoadFunction<d_gtk_button_new_from_stock>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_button_new_from_stock"));
 
@@ -51,3 +51,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/CellRenderer.cs

@@ -27,7 +27,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class CellRenderer {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_cell_renderer_start_editing(IntPtr handle, IntPtr evnt, IntPtr widget, IntPtr path, ref Gdk.Rectangle bg_area, ref Gdk.Rectangle cell_area, int flags);
 		static d_gtk_cell_renderer_start_editing gtk_cell_renderer_start_editing = FuncLoader.LoadFunction<d_gtk_cell_renderer_start_editing>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_cell_renderer_start_editing"));
 
@@ -39,7 +39,7 @@ namespace Gtk {
 			var ret = (ICellEditable) GLib.Object.GetObject (raw_ret);
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_cell_renderer_render2(IntPtr handle, IntPtr drawable, IntPtr widget, ref Gdk.Rectangle bg_area, ref Gdk.Rectangle cell_area, ref Gdk.Rectangle expose_area, int flags);
 		static d_gtk_cell_renderer_render2 gtk_cell_renderer_render2 = FuncLoader.LoadFunction<d_gtk_cell_renderer_render2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_cell_renderer_render"));
 		
@@ -54,3 +54,4 @@ namespace Gtk {
 		delegate void OnGetSizeDelegate (IntPtr item, IntPtr widget, IntPtr cell_area_ptr, IntPtr x_offset, IntPtr y_offset, IntPtr width, IntPtr height);
 	}
 }
+

Source/Libs/GtkSharp/CheckMenuItem.cs

@@ -24,7 +24,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class CheckMenuItem {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_check_menu_item_new_with_mnemonic(IntPtr label);
 		static d_gtk_check_menu_item_new_with_mnemonic gtk_check_menu_item_new_with_mnemonic = FuncLoader.LoadFunction<d_gtk_check_menu_item_new_with_mnemonic>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_check_menu_item_new_with_mnemonic"));
 
@@ -50,3 +50,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Clipboard.cs

@@ -24,10 +24,10 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class Clipboard {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_clipboard_set_with_data(IntPtr raw, TargetEntry[] targets, int n_targets, GtkSharp.ClipboardGetFuncNative get_func, GtkSharp.ClipboardClearFuncNative clear_func, IntPtr data);
 		static d_gtk_clipboard_set_with_data gtk_clipboard_set_with_data = FuncLoader.LoadFunction<d_gtk_clipboard_set_with_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_clipboard_set_with_data"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_clipboard_set_with_owner(IntPtr raw, TargetEntry[] targets, int n_targets, GtkSharp.ClipboardGetFuncNative get_func, GtkSharp.ClipboardClearFuncNative clear_func, IntPtr owner);
 		static d_gtk_clipboard_set_with_owner gtk_clipboard_set_with_owner = FuncLoader.LoadFunction<d_gtk_clipboard_set_with_owner>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_clipboard_set_with_owner"));
 
@@ -72,7 +72,7 @@ namespace Gtk {
 		{
 			Text = text;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_clipboard_wait_for_rich_text(IntPtr raw, IntPtr buffer, out IntPtr format, out UIntPtr length);
 		static d_gtk_clipboard_wait_for_rich_text gtk_clipboard_wait_for_rich_text = FuncLoader.LoadFunction<d_gtk_clipboard_wait_for_rich_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_clipboard_wait_for_rich_text"));
 
@@ -114,7 +114,7 @@ namespace Gtk {
 				GLib.ExceptionManager.RaiseUnhandledException (e, false);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_clipboard_request_rich_text(IntPtr raw, IntPtr buffer, RichTextReceivedFuncNative cb, IntPtr user_data);
 		static d_gtk_clipboard_request_rich_text gtk_clipboard_request_rich_text = FuncLoader.LoadFunction<d_gtk_clipboard_request_rich_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_clipboard_request_rich_text"));
 
@@ -126,3 +126,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/ColorSelection.cs

@@ -22,7 +22,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class ColorSelection {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_color_selection_palette_to_string(Gdk.Color[] colors, int n_colors);
 		static d_gtk_color_selection_palette_to_string gtk_color_selection_palette_to_string = FuncLoader.LoadFunction<d_gtk_color_selection_palette_to_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_color_selection_palette_to_string"));
 
@@ -34,6 +34,7 @@ namespace Gtk {
 			return ret;
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_color_selection_palette_from_string(IntPtr str, out IntPtr colors, out int n_colors);
 		static d_gtk_color_selection_palette_from_string gtk_color_selection_palette_from_string = FuncLoader.LoadFunction<d_gtk_color_selection_palette_from_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_color_selection_palette_from_string"));
 
@@ -58,10 +59,10 @@ namespace Gtk {
 			}
 			return colors;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_color_selection_set_previous_color(IntPtr raw, ref Gdk.Color color);
 		static d_gtk_color_selection_set_previous_color gtk_color_selection_set_previous_color = FuncLoader.LoadFunction<d_gtk_color_selection_set_previous_color>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_color_selection_set_previous_color"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_color_selection_get_previous_color(IntPtr raw, out Gdk.Color color);
 		static d_gtk_color_selection_get_previous_color gtk_color_selection_get_previous_color = FuncLoader.LoadFunction<d_gtk_color_selection_get_previous_color>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_color_selection_get_previous_color"));
 
@@ -81,3 +82,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Container.cs

@@ -27,9 +27,10 @@ namespace Gtk
 
     public partial class Container : IEnumerable
     {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate GParamSpec d_gtk_container_class_find_child_property(IntPtr cclass, string property_name);
 		static d_gtk_container_class_find_child_property gtk_container_class_find_child_property = FuncLoader.LoadFunction<d_gtk_container_class_find_child_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_container_class_find_child_property"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_container_child_get_property(IntPtr container, IntPtr child, string property_name, ref GLib.Value value);
 		static d_gtk_container_child_get_property gtk_container_child_get_property = FuncLoader.LoadFunction<d_gtk_container_child_get_property>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_container_child_get_property"));
 
@@ -90,10 +91,10 @@ namespace Gtk
                 return acc.Children;
             }
         }
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_container_get_focus_chain(IntPtr raw, out IntPtr list_ptr);
 		static d_gtk_container_get_focus_chain gtk_container_get_focus_chain = FuncLoader.LoadFunction<d_gtk_container_get_focus_chain>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_container_get_focus_chain"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_container_set_focus_chain(IntPtr raw, IntPtr list_ptr);
 		static d_gtk_container_set_focus_chain gtk_container_set_focus_chain = FuncLoader.LoadFunction<d_gtk_container_set_focus_chain>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_container_set_focus_chain"));
 
@@ -226,3 +227,4 @@ namespace Gtk
         }
     }
 }
+

Source/Libs/GtkSharp/Dialog.cs

@@ -26,6 +26,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class Dialog {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_dialog_new_with_buttons(IntPtr title, IntPtr i, int flags, IntPtr dummy);
 		static d_gtk_dialog_new_with_buttons gtk_dialog_new_with_buttons = FuncLoader.LoadFunction<d_gtk_dialog_new_with_buttons>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_dialog_new_with_buttons"));
 		public Dialog (string title, Gtk.Window parent, Gtk.DialogFlags flags, params object[] button_data) : base(IntPtr.Zero)
@@ -60,3 +61,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Drag.cs

@@ -22,7 +22,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class Drag {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_drag_set_icon_default(IntPtr context);
 		static d_gtk_drag_set_icon_default gtk_drag_set_icon_default = FuncLoader.LoadFunction<d_gtk_drag_set_icon_default>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_drag_set_icon_default"));
 
@@ -39,3 +39,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/FileChooserDialog.cs

@@ -27,7 +27,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class FileChooserDialog {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_file_chooser_dialog_new(IntPtr title, IntPtr parent, int action, IntPtr nil);
 		static d_gtk_file_chooser_dialog_new gtk_file_chooser_dialog_new = FuncLoader.LoadFunction<d_gtk_file_chooser_dialog_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_file_chooser_dialog_new"));
 
@@ -50,3 +50,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/FileChooserNative.cs

@@ -26,19 +26,19 @@ namespace Gtk {
 	public partial class FileChooserNative : Gtk.NativeDialog, Gtk.IFileChooser {
 
 		public FileChooserNative (IntPtr raw) : base(raw) {}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_file_chooser_native_new(IntPtr title, IntPtr parent, int action, IntPtr accept_label, IntPtr cancel_label);
 		static d_gtk_file_chooser_native_new gtk_file_chooser_native_new = FuncLoader.LoadFunction<d_gtk_file_chooser_native_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_file_chooser_native_new"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate string d_gtk_file_chooser_native_get_accept_label(IntPtr self);
 		static d_gtk_file_chooser_native_get_accept_label gtk_file_chooser_native_get_accept_label = FuncLoader.LoadFunction<d_gtk_file_chooser_native_get_accept_label>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_file_chooser_native_get_accept_label"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate string d_gtk_file_chooser_native_set_accept_label(IntPtr self, string accept_label);
 		static d_gtk_file_chooser_native_set_accept_label gtk_file_chooser_native_set_accept_label = FuncLoader.LoadFunction<d_gtk_file_chooser_native_set_accept_label>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_file_chooser_native_set_accept_label"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate string d_gtk_file_chooser_native_get_cancel_label(IntPtr self);
 		static d_gtk_file_chooser_native_get_cancel_label gtk_file_chooser_native_get_cancel_label = FuncLoader.LoadFunction<d_gtk_file_chooser_native_get_cancel_label>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_file_chooser_native_get_cancel_label"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate string d_gtk_file_chooser_native_set_cancel_label(IntPtr self, string cancel_label);
 		static d_gtk_file_chooser_native_set_cancel_label gtk_file_chooser_native_set_cancel_label = FuncLoader.LoadFunction<d_gtk_file_chooser_native_set_cancel_label>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_file_chooser_native_set_cancel_label"));
 
@@ -86,3 +86,4 @@ namespace Gtk {
                 }
 	}
 }
+

Source/Libs/GtkSharp/HScale.cs

@@ -24,7 +24,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class HScale {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_hscale_new_with_range(double min, double max, double step);
 		static d_gtk_hscale_new_with_range gtk_hscale_new_with_range = FuncLoader.LoadFunction<d_gtk_hscale_new_with_range>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_hscale_new_with_range"));
 
@@ -45,3 +45,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/IconFactory.cs

@@ -19,7 +19,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class IconFactory {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_icon_size_lookup(IconSize size, out int width, out int height);
 		static d_gtk_icon_size_lookup gtk_icon_size_lookup = FuncLoader.LoadFunction<d_gtk_icon_size_lookup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_icon_size_lookup"));
 
@@ -31,3 +31,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/IconSet.cs

@@ -19,7 +19,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class IconSet {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		unsafe delegate void d_gtk_icon_set_get_sizes(IntPtr raw, out int *pointer_to_enum, out int n_sizes);
 		static d_gtk_icon_set_get_sizes gtk_icon_set_get_sizes = FuncLoader.LoadFunction<d_gtk_icon_set_get_sizes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_icon_set_get_sizes"));
 
@@ -46,3 +46,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/IconTheme.cs

@@ -27,7 +27,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class IconTheme {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_icon_theme_list_icons(IntPtr raw, IntPtr context);
 		static d_gtk_icon_theme_list_icons gtk_icon_theme_list_icons = FuncLoader.LoadFunction<d_gtk_icon_theme_list_icons>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_icon_theme_list_icons"));
 
@@ -46,16 +46,16 @@ namespace Gtk {
 				result [i++] = val;
 			return result;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_icon_theme_get_search_path(IntPtr raw, out IntPtr path, out int n_elements);
 		static d_gtk_icon_theme_get_search_path gtk_icon_theme_get_search_path = FuncLoader.LoadFunction<d_gtk_icon_theme_get_search_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_icon_theme_get_search_path"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_icon_theme_set_search_path(IntPtr raw, IntPtr[] path, int n_elements);
 		static d_gtk_icon_theme_set_search_path gtk_icon_theme_set_search_path = FuncLoader.LoadFunction<d_gtk_icon_theme_set_search_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_icon_theme_set_search_path"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_icon_theme_get_search_path_utf8(IntPtr raw, out IntPtr path, out int n_elements);
 		static d_gtk_icon_theme_get_search_path_utf8 gtk_icon_theme_get_search_path_utf8 = FuncLoader.LoadFunction<d_gtk_icon_theme_get_search_path_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_icon_theme_get_search_path_utf8"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_icon_theme_set_search_path_utf8(IntPtr raw, IntPtr[] path, int n_elements);
 		static d_gtk_icon_theme_set_search_path_utf8 gtk_icon_theme_set_search_path_utf8 = FuncLoader.LoadFunction<d_gtk_icon_theme_set_search_path_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_icon_theme_set_search_path_utf8"));
 
@@ -106,7 +106,7 @@ namespace Gtk {
 		{
 			SearchPath = path;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_icon_theme_get_icon_sizes(IntPtr raw, IntPtr icon_name);
 		static d_gtk_icon_theme_get_icon_sizes gtk_icon_theme_get_icon_sizes = FuncLoader.LoadFunction<d_gtk_icon_theme_get_icon_sizes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_icon_theme_get_icon_sizes"));
 
@@ -128,3 +128,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/IconView.cs

@@ -35,7 +35,7 @@ namespace Gtk {
 				AddAttribute (cell, (string) attrs [i], (int) attrs [i + 1]);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_icon_view_scroll_to_path(IntPtr raw, IntPtr path, bool use_align, float row_align, float col_align);
 		static d_gtk_icon_view_scroll_to_path gtk_icon_view_scroll_to_path = FuncLoader.LoadFunction<d_gtk_icon_view_scroll_to_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_icon_view_scroll_to_path"));
 
@@ -50,3 +50,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Image.cs

@@ -26,7 +26,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class Image {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_image_new_from_icon_set(IntPtr icon_set, int size);
 		static d_gtk_image_new_from_icon_set gtk_image_new_from_icon_set = FuncLoader.LoadFunction<d_gtk_image_new_from_icon_set>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_image_new_from_icon_set"));
 
@@ -44,7 +44,7 @@ namespace Gtk {
 			}
 			Raw = gtk_image_new_from_icon_set(icon_set.Handle, (int) size);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_image_new_from_stock(IntPtr stock_id, int size);
 		static d_gtk_image_new_from_stock gtk_image_new_from_stock = FuncLoader.LoadFunction<d_gtk_image_new_from_stock>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_image_new_from_stock"));
 
@@ -124,3 +124,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/ImageMenuItem.cs

@@ -24,7 +24,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class ImageMenuItem {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_image_menu_item_new_with_mnemonic(IntPtr label);
 		static d_gtk_image_menu_item_new_with_mnemonic gtk_image_menu_item_new_with_mnemonic = FuncLoader.LoadFunction<d_gtk_image_menu_item_new_with_mnemonic>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_image_menu_item_new_with_mnemonic"));
 
@@ -46,3 +46,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Key.cs

@@ -27,7 +27,7 @@ namespace Gtk {
 	public class Key {
 
 		static Hashtable wrappers = new Hashtable ();
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate uint d_gtk_key_snooper_install(GtkSharp.KeySnoopFuncNative snooper, IntPtr func_data);
 		static d_gtk_key_snooper_install gtk_key_snooper_install = FuncLoader.LoadFunction<d_gtk_key_snooper_install>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_key_snooper_install"));
 
@@ -38,7 +38,7 @@ namespace Gtk {
 			wrappers [ret] = snooper_wrapper;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_key_snooper_remove(uint snooper_handler_id);
 		static d_gtk_key_snooper_remove gtk_key_snooper_remove = FuncLoader.LoadFunction<d_gtk_key_snooper_remove>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_key_snooper_remove"));
 
@@ -49,3 +49,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/ListStore.cs

@@ -25,7 +25,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class ListStore : IEnumerable {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_tree_model_iter_children2(IntPtr raw, out Gtk.TreeIter iter, IntPtr parent);
 		static d_gtk_tree_model_iter_children2 gtk_tree_model_iter_children2 = FuncLoader.LoadFunction<d_gtk_tree_model_iter_children2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_tree_model_iter_children"));
 		public bool IterChildren (out Gtk.TreeIter iter) 
@@ -41,7 +41,7 @@ namespace Gtk {
 			int ret = raw_ret;
 			return ret;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_tree_model_iter_nth_child2(IntPtr raw, out Gtk.TreeIter iter, IntPtr parent, int n);
 		static d_gtk_tree_model_iter_nth_child2 gtk_tree_model_iter_nth_child2 = FuncLoader.LoadFunction<d_gtk_tree_model_iter_nth_child2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_tree_model_iter_nth_child"));
 		public bool IterNthChild (out Gtk.TreeIter iter, int n) 
@@ -120,7 +120,7 @@ namespace Gtk {
 			SetValues (iter, values);
 			return iter;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_list_store_insert_with_valuesv2(IntPtr raw, out TreeIter iter, int position, int[] columns, GLib.Value[] values, int n_values);
 		static d_gtk_list_store_insert_with_valuesv2 gtk_list_store_insert_with_valuesv2 = FuncLoader.LoadFunction<d_gtk_list_store_insert_with_valuesv2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_list_store_insert_with_valuesv"));
 
@@ -146,7 +146,7 @@ namespace Gtk {
 
 			return iter;
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_list_store_set_valuesv(IntPtr raw, ref TreeIter iter, int[] columns, GLib.Value[] values, int n_values);
 		static d_gtk_list_store_set_valuesv gtk_list_store_set_valuesv = FuncLoader.LoadFunction<d_gtk_list_store_set_valuesv>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_list_store_set_valuesv"));
 
@@ -293,3 +293,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Menu.cs

@@ -34,7 +34,7 @@ namespace Gtk {
 		{
 			PopupAtPointer (null);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_menu_set_screen(IntPtr raw, IntPtr screen);
 		static d_gtk_menu_set_screen gtk_menu_set_screen = FuncLoader.LoadFunction<d_gtk_menu_set_screen>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_menu_set_screen"));
 
@@ -46,7 +46,7 @@ namespace Gtk {
 				gtk_menu_set_screen (Handle, value.Handle);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_menu_set_active(IntPtr raw, uint index_);
 		static d_gtk_menu_set_active gtk_menu_set_active = FuncLoader.LoadFunction<d_gtk_menu_set_active>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_menu_set_active"));
 
@@ -56,3 +56,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/MenuItem.cs

@@ -25,6 +25,7 @@ namespace Gtk {
 
 	public partial class MenuItem {
 				
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_menu_item_new_with_mnemonic(IntPtr label);
 		static d_gtk_menu_item_new_with_mnemonic gtk_menu_item_new_with_mnemonic = FuncLoader.LoadFunction<d_gtk_menu_item_new_with_mnemonic>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_menu_item_new_with_mnemonic"));
 
@@ -46,3 +47,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/MessageDialog.cs

@@ -19,10 +19,10 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class MessageDialog {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_message_dialog_new(IntPtr parent_window, DialogFlags flags, MessageType type, ButtonsType bt, IntPtr msg, IntPtr args);
 		static d_gtk_message_dialog_new gtk_message_dialog_new = FuncLoader.LoadFunction<d_gtk_message_dialog_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_message_dialog_new"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_message_dialog_new_with_markup(IntPtr parent_window, DialogFlags flags, MessageType type, ButtonsType bt, IntPtr msg, IntPtr args);
 		static d_gtk_message_dialog_new_with_markup gtk_message_dialog_new_with_markup = FuncLoader.LoadFunction<d_gtk_message_dialog_new_with_markup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_message_dialog_new_with_markup"));
 
@@ -47,3 +47,4 @@ namespace Gtk {
 
 	}
 }
+

Source/Libs/GtkSharp/NativeDialog.cs

@@ -26,7 +26,7 @@ namespace Gtk {
 	public partial class NativeDialog : Gtk.FileChooserAdapter {
 
 		public NativeDialog (IntPtr raw) : base(raw) { }
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_native_dialog_show(IntPtr self);
 		static d_gtk_native_dialog_show gtk_native_dialog_show = FuncLoader.LoadFunction<d_gtk_native_dialog_show>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_native_dialog_show"));
 
@@ -34,7 +34,7 @@ namespace Gtk {
 		{
 			gtk_native_dialog_show (Handle);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_native_dialog_hide(IntPtr self);
 		static d_gtk_native_dialog_hide gtk_native_dialog_hide = FuncLoader.LoadFunction<d_gtk_native_dialog_hide>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_native_dialog_hide"));
 
@@ -42,7 +42,7 @@ namespace Gtk {
                 {
                         gtk_native_dialog_hide (Handle);
                 }
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_native_dialog_destroy(IntPtr self);
 		static d_gtk_native_dialog_destroy gtk_native_dialog_destroy = FuncLoader.LoadFunction<d_gtk_native_dialog_destroy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_native_dialog_destroy"));
 
@@ -50,7 +50,7 @@ namespace Gtk {
                 {
                         gtk_native_dialog_destroy (Handle);
                 }
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_native_dialog_get_visible(IntPtr self);
 		static d_gtk_native_dialog_get_visible gtk_native_dialog_get_visible = FuncLoader.LoadFunction<d_gtk_native_dialog_get_visible>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_native_dialog_get_visible"));
 
@@ -59,10 +59,10 @@ namespace Gtk {
 				return gtk_native_dialog_get_visible (Handle);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_native_dialog_set_modal(IntPtr self, bool modal);
 		static d_gtk_native_dialog_set_modal gtk_native_dialog_set_modal = FuncLoader.LoadFunction<d_gtk_native_dialog_set_modal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_native_dialog_set_modal"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_native_dialog_get_modal(IntPtr self);
 		static d_gtk_native_dialog_get_modal gtk_native_dialog_get_modal = FuncLoader.LoadFunction<d_gtk_native_dialog_get_modal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_native_dialog_get_modal"));
 
@@ -74,10 +74,10 @@ namespace Gtk {
                                 return gtk_native_dialog_get_modal (Handle);
                         }
                 }
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_native_dialog_set_title(IntPtr self, string title);
 		static d_gtk_native_dialog_set_title gtk_native_dialog_set_title = FuncLoader.LoadFunction<d_gtk_native_dialog_set_title>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_native_dialog_set_title"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate string d_gtk_native_dialog_get_title(IntPtr self);
 		static d_gtk_native_dialog_get_title gtk_native_dialog_get_title = FuncLoader.LoadFunction<d_gtk_native_dialog_get_title>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_native_dialog_get_title"));
 
@@ -89,13 +89,13 @@ namespace Gtk {
                                 return gtk_native_dialog_get_title (Handle);
                         }
                 }
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_native_dialog_set_transient_for(IntPtr self, IntPtr parent);
 		static d_gtk_native_dialog_set_transient_for gtk_native_dialog_set_transient_for = FuncLoader.LoadFunction<d_gtk_native_dialog_set_transient_for>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_native_dialog_set_transient_for"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_native_dialog_get_transient_for(IntPtr self);
 		static d_gtk_native_dialog_get_transient_for gtk_native_dialog_get_transient_for = FuncLoader.LoadFunction<d_gtk_native_dialog_get_transient_for>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_native_dialog_get_transient_for"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_gtk_native_dialog_run(IntPtr self);
 		static d_gtk_native_dialog_run gtk_native_dialog_run = FuncLoader.LoadFunction<d_gtk_native_dialog_run>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_native_dialog_run"));
 
@@ -105,3 +105,4 @@ namespace Gtk {
                 }
 	}
 }
+

Source/Libs/GtkSharp/Notebook.cs

@@ -31,7 +31,7 @@ namespace Gtk {
 				return GetNthPage (CurrentPage);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate int d_gtk_notebook_page_num(IntPtr handle, IntPtr child);
 		static d_gtk_notebook_page_num gtk_notebook_page_num = FuncLoader.LoadFunction<d_gtk_notebook_page_num>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_notebook_page_num"));
 
@@ -41,3 +41,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Plug.cs

@@ -25,7 +25,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class Plug {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_plug_new(UIntPtr socket_id);
 		static d_gtk_plug_new gtk_plug_new = FuncLoader.LoadFunction<d_gtk_plug_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_plug_new"));
 
@@ -38,7 +38,7 @@ namespace Gtk {
 			}
 			Raw = gtk_plug_new (new UIntPtr (socket_id));
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_plug_new_for_display(IntPtr display, UIntPtr socket_id);
 		static d_gtk_plug_new_for_display gtk_plug_new_for_display = FuncLoader.LoadFunction<d_gtk_plug_new_for_display>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_plug_new_for_display"));
 
@@ -53,3 +53,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/Printer.cs

@@ -24,7 +24,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class Printer {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_enumerate_printers(GtkSharp.PrinterFuncNative func, IntPtr func_data, GLib.DestroyNotify destroy, bool wait);
 		static d_gtk_enumerate_printers gtk_enumerate_printers = FuncLoader.LoadFunction<d_gtk_enumerate_printers>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_enumerate_printers"));
 
@@ -46,3 +46,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/RadioAction.cs

@@ -25,9 +25,10 @@ namespace Gtk
 
 	public partial class RadioAction
 	{
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_radio_action_get_group(IntPtr raw);
 		static d_gtk_radio_action_get_group gtk_radio_action_get_group = FuncLoader.LoadFunction<d_gtk_radio_action_get_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_radio_action_get_group"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_radio_action_set_group(IntPtr raw, IntPtr list);
 		static d_gtk_radio_action_set_group gtk_radio_action_set_group = FuncLoader.LoadFunction<d_gtk_radio_action_set_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_radio_action_set_group"));
 
@@ -52,3 +53,4 @@ namespace Gtk
 		}
 	}
 }
+

Source/Libs/GtkSharp/RadioButton.cs

@@ -24,7 +24,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class RadioButton {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_radio_button_new_with_mnemonic(IntPtr group, IntPtr label);
 		static d_gtk_radio_button_new_with_mnemonic gtk_radio_button_new_with_mnemonic = FuncLoader.LoadFunction<d_gtk_radio_button_new_with_mnemonic>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_radio_button_new_with_mnemonic"));
 
@@ -35,10 +35,10 @@ namespace Gtk {
 			Raw = gtk_radio_button_new_with_mnemonic (IntPtr.Zero, native);
 			GLib.Marshaller.Free (native);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_radio_button_get_group(IntPtr raw);
 		static d_gtk_radio_button_get_group gtk_radio_button_get_group = FuncLoader.LoadFunction<d_gtk_radio_button_get_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_radio_button_get_group"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_radio_button_set_group(IntPtr raw, IntPtr list);
 		static d_gtk_radio_button_set_group gtk_radio_button_set_group = FuncLoader.LoadFunction<d_gtk_radio_button_set_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_radio_button_set_group"));
 
@@ -63,3 +63,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/RadioMenuItem.cs

@@ -42,7 +42,7 @@ namespace Gtk {
 			Raw = gtk_radio_menu_item_new_with_mnemonic (IntPtr.Zero, label_as_native);
 			GLib.Marshaller.Free (label_as_native);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_radio_menu_item_new_with_mnemonic(IntPtr group, IntPtr label);
 		static d_gtk_radio_menu_item_new_with_mnemonic gtk_radio_menu_item_new_with_mnemonic = FuncLoader.LoadFunction<d_gtk_radio_menu_item_new_with_mnemonic>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_radio_menu_item_new_with_mnemonic"));
 
@@ -70,10 +70,10 @@ namespace Gtk {
 			Raw = gtk_radio_menu_item_new_with_mnemonic(native_group, native_label);
 			GLib.Marshaller.Free (native_label);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_radio_menu_item_get_group(IntPtr raw);
 		static d_gtk_radio_menu_item_get_group gtk_radio_menu_item_get_group = FuncLoader.LoadFunction<d_gtk_radio_menu_item_get_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_radio_menu_item_get_group"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_radio_menu_item_set_group(IntPtr raw, IntPtr list);
 		static d_gtk_radio_menu_item_set_group gtk_radio_menu_item_set_group = FuncLoader.LoadFunction<d_gtk_radio_menu_item_set_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_radio_menu_item_set_group"));
 
@@ -98,3 +98,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/RadioToolButton.cs

@@ -24,7 +24,7 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class RadioToolButton {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_radio_tool_button_new(IntPtr group);
 		static d_gtk_radio_tool_button_new gtk_radio_tool_button_new = FuncLoader.LoadFunction<d_gtk_radio_tool_button_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_radio_tool_button_new"));
 
@@ -45,7 +45,7 @@ namespace Gtk {
 			}
 			Raw = gtk_radio_tool_button_new(native_group);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_radio_tool_button_new_from_stock(IntPtr group, IntPtr stock_id);
 		static d_gtk_radio_tool_button_new_from_stock gtk_radio_tool_button_new_from_stock = FuncLoader.LoadFunction<d_gtk_radio_tool_button_new_from_stock>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_radio_tool_button_new_from_stock"));
 
@@ -71,10 +71,10 @@ namespace Gtk {
 			Raw = gtk_radio_tool_button_new_from_stock(native_group, stock_id_as_native);
 			GLib.Marshaller.Free (stock_id_as_native);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_radio_tool_button_get_group(IntPtr raw);
 		static d_gtk_radio_tool_button_get_group gtk_radio_tool_button_get_group = FuncLoader.LoadFunction<d_gtk_radio_tool_button_get_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_radio_tool_button_get_group"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_radio_tool_button_set_group(IntPtr raw, IntPtr list);
 		static d_gtk_radio_tool_button_set_group gtk_radio_tool_button_set_group = FuncLoader.LoadFunction<d_gtk_radio_tool_button_set_group>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_radio_tool_button_set_group"));
 
@@ -99,3 +99,4 @@ namespace Gtk {
 		}
 	}
 }
+

Source/Libs/GtkSharp/SelectionData.cs

@@ -24,10 +24,10 @@ namespace Gtk {
 	using System.Runtime.InteropServices;
 
 	public partial class SelectionData {
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_selection_data_get_text(IntPtr selection_data);
 		static d_gtk_selection_data_get_text gtk_selection_data_get_text = FuncLoader.LoadFunction<d_gtk_selection_data_get_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_selection_data_get_text"));
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate void d_gtk_selection_data_set_text(IntPtr selection_data, IntPtr str, int len);
 		static d_gtk_selection_data_set_text gtk_selection_data_set_text = FuncLoader.LoadFunction<d_gtk_selection_data_set_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_selection_data_set_text"));
 
@@ -44,7 +44,7 @@ namespace Gtk {
 				GLib.Marshaller.Free (native);
 			}
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate IntPtr d_gtk_selection_data_get_data(IntPtr selection_data);
 		static d_gtk_selection_data_get_data gtk_selection_data_get_data = FuncLoader.LoadFunction<d_gtk_selection_data_get_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_selection_data_get_data"));
 
@@ -60,7 +60,7 @@ namespace Gtk {
 		public void Set(Gdk.Atom type, int format, byte[] data) {
 			Set(type, format, data, data.Length);
 		}
-
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 		delegate bool d_gtk_selection_data_get_targets(IntPtr raw, out IntPtr targets, out int n_atoms);
 		static d_gtk_selection_data_get_targets gtk_selection_data_get_targets = FuncLoader.LoadFunction<d_gtk_selection_data_get_targets>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_selection_data_get_targets"));
 
@@ -82,3 +82,4 @@ namespace Gtk {
 		}
 	}
 }
+