no more submodule

GtkSharp/Source/Libs/PangoSharp/Analysis.cs

@@ -0,0 +1,70 @@
+// Pango.Analysis.cs - Pango Analysis class customizations
+//
+// Authors:  Mike Kestner  <mkestner@novell.com>
+//
+// Copyright (c) 2004 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+
+	public partial struct Analysis {
+
+		public Attribute[] ExtraAttrs {
+			get {
+				GLib.SList list = new GLib.SList (_extra_attrs, typeof (IntPtr));
+				Attribute[] result = new Attribute [list.Count];
+				int i = 0;
+				foreach (IntPtr attr in list)
+					result [i++] = Attribute.GetAttribute (attr);
+				return result;
+			}
+		}
+
+		[Obsolete ("Replaced by ShapeEngine property")]
+		public Pango.EngineShape shape_engine {
+			get { 
+				return _shape_engine == IntPtr.Zero ? null : new Pango.EngineShape(_shape_engine);
+			}
+			set { _shape_engine = value == null ? IntPtr.Zero : value.Handle; }
+		}
+
+		[Obsolete ("Replaced by LangEngine property")]
+		public Pango.EngineLang lang_engine {
+			get { 
+				return _lang_engine == IntPtr.Zero ? null : new Pango.EngineLang(_lang_engine);
+			}
+			set { _lang_engine = value == null ? IntPtr.Zero : value.Handle; }
+		}
+
+		[Obsolete ("Replaced by Font property")]
+		public Pango.Font font {
+			get { 
+				return GLib.Object.GetObject(_font) as Pango.Font;
+			}
+			set { _font = value == null ? IntPtr.Zero : value.Handle; }
+		}
+
+		[Obsolete ("Replaced by Language property")]
+		public Pango.Language language {
+			get { 
+				return _language == IntPtr.Zero ? null : new Pango.Language(_language);
+			}
+			set { _language = value == null ? IntPtr.Zero : value.Handle; }
+		}
+	}
+}

GtkSharp/Source/Libs/PangoSharp/AttrBackground.cs

@@ -0,0 +1,42 @@
+// Pango.AttrBackground - Pango.Attribute for background color
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrBackground : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_background_new(ushort red, ushort green, ushort blue);
+		static d_pango_attr_background_new pango_attr_background_new = FuncLoader.LoadFunction<d_pango_attr_background_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_background_new"));
+
+		public AttrBackground (ushort red, ushort green, ushort blue) : this (pango_attr_background_new (red, green, blue)) {}
+
+		public AttrBackground (Pango.Color color) : this (pango_attr_background_new (color.Red, color.Green, color.Blue)) {}
+
+		internal AttrBackground (IntPtr raw) : base (raw) {}
+
+		public Pango.Color Color {
+			get {
+				return AttrColor.New (Handle).Color;
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrColor.cs

@@ -0,0 +1,33 @@
+// Pango.AttrColor - Pango.Attribute for Colors
+//
+// Copyright (c) 2008 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	internal struct AttrColor {
+		Attribute.NativeStruct attr;
+		public Color Color;
+
+		public static AttrColor New (IntPtr raw)
+		{
+			return (AttrColor) Marshal.PtrToStructure (raw, typeof (AttrColor));
+		}
+	}
+}

GtkSharp/Source/Libs/PangoSharp/AttrFallback.cs

@@ -0,0 +1,40 @@
+// Pango.AttrFallback - Pango.Attribute for font fallback
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrFallback : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_fallback_new(bool fallback);
+		static d_pango_attr_fallback_new pango_attr_fallback_new = FuncLoader.LoadFunction<d_pango_attr_fallback_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_fallback_new"));
+
+		public AttrFallback (bool fallback) : this (pango_attr_fallback_new (fallback)) {}
+
+		internal AttrFallback (IntPtr raw) : base (raw) {}
+
+		public bool Fallback {
+			get {
+				return AttrInt.New (Handle).Value != 0;
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrFamily.cs

@@ -0,0 +1,54 @@
+// Pango.AttrFamily - Pango.Attribute for font families
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrFamily : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_family_new(IntPtr family);
+		static d_pango_attr_family_new pango_attr_family_new = FuncLoader.LoadFunction<d_pango_attr_family_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_family_new"));
+
+		public AttrFamily (string family) : base (NewAttrFamily (family)) {}
+
+		static IntPtr NewAttrFamily (string family)
+		{
+			IntPtr family_raw = GLib.Marshaller.StringToPtrGStrdup (family);
+			IntPtr attr_raw = pango_attr_family_new (family_raw);
+			GLib.Marshaller.Free (family_raw);
+			return attr_raw;
+		}
+
+		internal AttrFamily (IntPtr raw) : base (raw) {}
+
+		new struct NativeStruct {
+			Attribute.NativeStruct attr;
+			public IntPtr value;
+		}
+
+		public string Family {
+			get {
+				NativeStruct native = (NativeStruct) Marshal.PtrToStructure (Handle, typeof (NativeStruct));
+				return GLib.Marshaller.Utf8PtrToString (native.value);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrFloat.cs

@@ -0,0 +1,33 @@
+// Pango.AttrFloat - Pango.Attribute for floating point values
+//
+// Copyright (c) 2008 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	internal struct AttrFloat {
+		Attribute.NativeStruct attr;
+		public double Value;
+
+		public static AttrFloat New (IntPtr raw)
+		{
+			return (AttrFloat) Marshal.PtrToStructure (raw, typeof (AttrFloat));
+		}
+	}
+}

GtkSharp/Source/Libs/PangoSharp/AttrFontDesc.cs

@@ -0,0 +1,49 @@
+// Pango.AttrFontDesc - Pango.Attribute for Pango.FontDescription
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrFontDesc : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_font_desc_new(IntPtr font_desc);
+		static d_pango_attr_font_desc_new pango_attr_font_desc_new = FuncLoader.LoadFunction<d_pango_attr_font_desc_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_font_desc_new"));
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_description_copy(IntPtr raw);
+		static d_pango_font_description_copy pango_font_description_copy = FuncLoader.LoadFunction<d_pango_font_description_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_copy"));
+
+		public AttrFontDesc (Pango.FontDescription font_desc) : this (pango_attr_font_desc_new (pango_font_description_copy (font_desc.Handle))) {}
+
+		internal AttrFontDesc (IntPtr raw) : base (raw) {}
+
+		new struct NativeStruct {
+			Attribute.NativeStruct attr;
+			public IntPtr desc;
+		}
+
+		public Pango.FontDescription Desc {
+			get {
+				NativeStruct native = (NativeStruct) Marshal.PtrToStructure (Handle, typeof (NativeStruct));
+				return new Pango.FontDescription (native.desc);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrForeground.cs

@@ -0,0 +1,42 @@
+// Pango.AttrForeground - Pango.Attribute for foreground color
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrForeground : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_foreground_new(ushort red, ushort green, ushort blue);
+		static d_pango_attr_foreground_new pango_attr_foreground_new = FuncLoader.LoadFunction<d_pango_attr_foreground_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_foreground_new"));
+
+		public AttrForeground (ushort red, ushort green, ushort blue) : this (pango_attr_foreground_new (red, green, blue)) {}
+
+		public AttrForeground (Pango.Color color) : this (pango_attr_foreground_new (color.Red, color.Green, color.Blue)) {}
+
+		internal AttrForeground (IntPtr raw) : base (raw) {}
+
+		public Pango.Color Color {
+			get {
+				return AttrColor.New (Handle).Color;
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrGravity.cs

@@ -0,0 +1,40 @@
+// Pango.AttrGravity - Pango.Attribute for Gravity
+//
+// Copyright (c) 2007 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrGravity : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_gravity_new(int gravity);
+		static d_pango_attr_gravity_new pango_attr_gravity_new = FuncLoader.LoadFunction<d_pango_attr_gravity_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_gravity_new"));
+
+		public AttrGravity (Gravity gravity) : this (pango_attr_gravity_new ((int) gravity)) {}
+
+		internal AttrGravity (IntPtr raw) : base (raw) {}
+
+		public Gravity Gravity {
+			get {
+				return (Gravity) (AttrInt.New (Handle).Value);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrGravityHint.cs

@@ -0,0 +1,40 @@
+// Pango.AttrGravityHint - Pango.Attribute for GravityHint
+//
+// Copyright (c) 2007 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrGravityHint : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_gravity_hint_new(int hint);
+		static d_pango_attr_gravity_hint_new pango_attr_gravity_hint_new = FuncLoader.LoadFunction<d_pango_attr_gravity_hint_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_gravity_hint_new"));
+
+		public AttrGravityHint (GravityHint hint) : this (pango_attr_gravity_hint_new ((int) hint)) {}
+
+		internal AttrGravityHint (IntPtr raw) : base (raw) {}
+
+		public GravityHint GravityHint {
+			get {
+				return (GravityHint) (AttrInt.New (Handle).Value);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrInt.cs

@@ -0,0 +1,33 @@
+// Pango.AttrInt - Pango.Attribute for integer values
+//
+// Copyright (c) 2008 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	internal struct AttrInt {
+		Attribute.NativeStruct attr;
+		public int Value;
+
+		public static AttrInt New (IntPtr raw)
+		{
+			return (AttrInt) Marshal.PtrToStructure (raw, typeof (AttrInt));
+		}
+	}
+}

GtkSharp/Source/Libs/PangoSharp/AttrIterator.cs

@@ -0,0 +1,67 @@
+// Pango.AttrIterator.cs - Pango AttrIterator class customizations
+//
+// Author: Mike Kestner  <mkestner@ximian.com>
+//
+// Copyright (c) 2004 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public partial class AttrIterator {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_pango_attr_iterator_get_font(IntPtr raw, IntPtr desc, out IntPtr language, out IntPtr extra_attrs);
+		static d_pango_attr_iterator_get_font pango_attr_iterator_get_font = FuncLoader.LoadFunction<d_pango_attr_iterator_get_font>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_iterator_get_font"));
+
+		public void GetFont (out Pango.FontDescription desc, out Pango.Language language, out Pango.Attribute[] extra_attrs)
+		{
+			desc = new FontDescription ();
+			IntPtr language_handle, list_handle;
+			pango_attr_iterator_get_font (Handle, desc.Handle, out language_handle, out list_handle);
+			desc.Family = desc.Family; // change static string to allocated one
+			language = language_handle == IntPtr.Zero ? null : new Language (language_handle);
+			if (list_handle == IntPtr.Zero) {
+				extra_attrs = new Pango.Attribute [0];
+				return;
+			}
+			GLib.SList list = new GLib.SList (list_handle);
+			extra_attrs = new Pango.Attribute [list.Count];
+			int i = 0;
+			foreach (IntPtr raw_attr in list)
+				extra_attrs [i++] = Pango.Attribute.GetAttribute (raw_attr);
+		}
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_iterator_get_attrs(IntPtr raw);
+		static d_pango_attr_iterator_get_attrs pango_attr_iterator_get_attrs = FuncLoader.LoadFunction<d_pango_attr_iterator_get_attrs>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_iterator_get_attrs"));
+
+		public Pango.Attribute[] Attrs {
+			get {
+				IntPtr list_handle = pango_attr_iterator_get_attrs (Handle);
+				if (list_handle == IntPtr.Zero)
+					return new Pango.Attribute [0];
+				GLib.SList list = new GLib.SList (list_handle);
+				Pango.Attribute[] attrs = new Pango.Attribute [list.Count];
+				int i = 0;
+				foreach (IntPtr raw_attr in list)
+					attrs [i++] = Pango.Attribute.GetAttribute (raw_attr);
+				return attrs;
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrLanguage.cs

@@ -0,0 +1,46 @@
+// Pango.AttrLanguage - Pango.Attribute for Pango.Language
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrLanguage : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_language_new(IntPtr language);
+		static d_pango_attr_language_new pango_attr_language_new = FuncLoader.LoadFunction<d_pango_attr_language_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_language_new"));
+
+		public AttrLanguage (Pango.Language language) : this (pango_attr_language_new (language.Handle)) {}
+
+		internal AttrLanguage (IntPtr raw) : base (raw) {}
+
+		new struct NativeStruct {
+			Attribute.NativeStruct attr;
+			public IntPtr value;
+		}
+
+		public Pango.Language Language {
+			get {
+				NativeStruct native = (NativeStruct) Marshal.PtrToStructure (Handle, typeof (NativeStruct));
+				return new Pango.Language (native.value);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrLetterSpacing.cs

@@ -0,0 +1,40 @@
+// Pango.AttrLetterSpacing - Pango.Attribute for baseline displacement
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrLetterSpacing : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_letter_spacing_new(int letter_spacing);
+		static d_pango_attr_letter_spacing_new pango_attr_letter_spacing_new = FuncLoader.LoadFunction<d_pango_attr_letter_spacing_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_letter_spacing_new"));
+
+		public AttrLetterSpacing (int letter_spacing) : this (pango_attr_letter_spacing_new (letter_spacing)) {}
+
+		internal AttrLetterSpacing (IntPtr raw) : base (raw) {}
+
+		public int LetterSpacing {
+			get {
+				return AttrInt.New (Handle).Value;
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrList.cs

@@ -0,0 +1,58 @@
+// Pango.AttrList.cs - Pango AttrList customizations
+//
+// Authors:  Mike Kestner  <mkestner@novell.com>
+//
+// Copyright (c) 2008 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public partial class AttrList {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attribute_copy(IntPtr raw);
+		static d_pango_attribute_copy pango_attribute_copy = FuncLoader.LoadFunction<d_pango_attribute_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attribute_copy"));
+
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_pango_attr_list_change(IntPtr raw, IntPtr attr);
+		static d_pango_attr_list_change pango_attr_list_change = FuncLoader.LoadFunction<d_pango_attr_list_change>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_list_change"));
+
+		public void Change (Pango.Attribute attr)
+		{
+			pango_attr_list_change (Handle, pango_attribute_copy (attr.Handle));
+		}
+
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_pango_attr_list_insert(IntPtr raw, IntPtr attr);
+		static d_pango_attr_list_insert pango_attr_list_insert = FuncLoader.LoadFunction<d_pango_attr_list_insert>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_list_insert"));
+
+		public void Insert (Pango.Attribute attr) 
+		{
+			pango_attr_list_insert (Handle, pango_attribute_copy (attr.Handle));
+		}
+
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_pango_attr_list_insert_before(IntPtr raw, IntPtr attr);
+		static d_pango_attr_list_insert_before pango_attr_list_insert_before = FuncLoader.LoadFunction<d_pango_attr_list_insert_before>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_list_insert_before"));
+
+		public void InsertBefore (Pango.Attribute attr)
+		{
+			pango_attr_list_insert_before (Handle, pango_attribute_copy (attr.Handle));
+		}
+	}
+}

GtkSharp/Source/Libs/PangoSharp/AttrRise.cs

@@ -0,0 +1,40 @@
+// Pango.AttrRise - Pango.Attribute for baseline displacement
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrRise : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_rise_new(int rise);
+		static d_pango_attr_rise_new pango_attr_rise_new = FuncLoader.LoadFunction<d_pango_attr_rise_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_rise_new"));
+
+		public AttrRise (int rise) : this (pango_attr_rise_new (rise)) {}
+
+		internal AttrRise (IntPtr raw) : base (raw) {}
+
+		public int Rise {
+			get {
+				return AttrInt.New (Handle).Value;
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrScale.cs

@@ -0,0 +1,40 @@
+// Pango.AttrScale - Pango.Attribute for font size scale
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrScale : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_scale_new(double scale);
+		static d_pango_attr_scale_new pango_attr_scale_new = FuncLoader.LoadFunction<d_pango_attr_scale_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_scale_new"));
+
+		public AttrScale (double scale) : this (pango_attr_scale_new (scale)) {}
+
+		internal AttrScale (IntPtr raw) : base (raw) {}
+
+		public double Scale {
+			get {
+				return AttrFloat.New (Handle).Value;
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrShape.cs

@@ -0,0 +1,57 @@
+// Pango.AttrShape - Pango.Attribute for shape restrictions
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrShape : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_shape_new(ref Pango.Rectangle ink_rect, ref Pango.Rectangle logical_rect);
+		static d_pango_attr_shape_new pango_attr_shape_new = FuncLoader.LoadFunction<d_pango_attr_shape_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_shape_new"));
+
+		public AttrShape (Pango.Rectangle ink_rect, Pango.Rectangle logical_rect) : this (pango_attr_shape_new (ref ink_rect, ref logical_rect)) {}
+
+		internal AttrShape (IntPtr raw) : base (raw) {}
+
+		new struct NativeStruct {
+			Attribute.NativeStruct attr;
+			public Rectangle ink_rect;
+			public Rectangle logical_rect;
+			IntPtr data;
+			IntPtr copy_func;
+			IntPtr destroy_func;
+		}
+
+		public Pango.Rectangle InkRect {
+			get {
+				NativeStruct native = (NativeStruct) Marshal.PtrToStructure (Handle, typeof (NativeStruct));
+				return native.ink_rect;
+			}
+		}
+
+		public Pango.Rectangle LogicalRect {
+			get {
+				NativeStruct native = (NativeStruct) Marshal.PtrToStructure (Handle, typeof (NativeStruct));
+				return native.logical_rect;
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrSize.cs

@@ -0,0 +1,59 @@
+// Pango.AttrSize - Pango.Attribute for font size
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrSize : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_size_new(int size);
+		static d_pango_attr_size_new pango_attr_size_new = FuncLoader.LoadFunction<d_pango_attr_size_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_size_new"));
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_size_new_absolute(int size);
+		static d_pango_attr_size_new_absolute pango_attr_size_new_absolute = FuncLoader.LoadFunction<d_pango_attr_size_new_absolute>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_size_new_absolute"));
+
+		public AttrSize (int size) : this (pango_attr_size_new (size)) {}
+
+		public AttrSize (int size, bool absolute) : this (absolute ? pango_attr_size_new (size) : pango_attr_size_new_absolute (size)) {}
+
+		internal AttrSize (IntPtr raw) : base (raw) {}
+
+		new struct NativeStruct {
+			Attribute.NativeStruct attr;
+			public int sz;
+			public uint absolute;
+		}
+
+		public int Size {
+			get {
+				NativeStruct native = (NativeStruct) Marshal.PtrToStructure (Handle, typeof (NativeStruct));
+				return native.sz;
+			}
+		}
+
+		public bool Absolute {
+			get {
+				NativeStruct native = (NativeStruct) Marshal.PtrToStructure (Handle, typeof (NativeStruct));
+				return native.absolute != 0;
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrStretch.cs

@@ -0,0 +1,40 @@
+// Pango.AttrStretch - Pango.Attribute for Pango.Stretch
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrStretch : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_stretch_new(Pango.Stretch stretch);
+		static d_pango_attr_stretch_new pango_attr_stretch_new = FuncLoader.LoadFunction<d_pango_attr_stretch_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_stretch_new"));
+
+		public AttrStretch (Pango.Stretch stretch) : this (pango_attr_stretch_new (stretch)) {}
+
+		internal AttrStretch (IntPtr raw) : base (raw) {}
+
+		public Pango.Stretch Stretch {
+			get {
+				return (Pango.Stretch) (AttrInt.New (Handle).Value);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrStrikethrough.cs

@@ -0,0 +1,40 @@
+// Pango.AttrStrikethrough - Pango.Attribute for strikethrough
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrStrikethrough : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_strikethrough_new(bool strikethrough);
+		static d_pango_attr_strikethrough_new pango_attr_strikethrough_new = FuncLoader.LoadFunction<d_pango_attr_strikethrough_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_strikethrough_new"));
+
+		public AttrStrikethrough (bool strikethrough) : this (pango_attr_strikethrough_new (strikethrough)) {}
+
+		internal AttrStrikethrough (IntPtr raw) : base (raw) {}
+
+		public bool Strikethrough {
+			get {
+				return AttrInt.New (Handle).Value != 0;
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrStrikethroughColor.cs

@@ -0,0 +1,42 @@
+// Pango.AttrStrikethroughColor - Pango.Attribute for strikethrough color
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrStrikethroughColor : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_strikethrough_color_new(ushort red, ushort green, ushort blue);
+		static d_pango_attr_strikethrough_color_new pango_attr_strikethrough_color_new = FuncLoader.LoadFunction<d_pango_attr_strikethrough_color_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_strikethrough_color_new"));
+
+		public AttrStrikethroughColor (ushort red, ushort green, ushort blue) : this (pango_attr_strikethrough_color_new (red, green, blue)) {}
+
+		public AttrStrikethroughColor (Pango.Color color) : this (pango_attr_strikethrough_color_new (color.Red, color.Green, color.Blue)) {}
+
+		internal AttrStrikethroughColor (IntPtr raw) : base (raw) {}
+
+		public Pango.Color Color {
+			get {
+				return AttrColor.New (Handle).Color;
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrStyle.cs

@@ -0,0 +1,40 @@
+// Pango.AttrStyle - Pango.Attribute for Pango.Style
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrStyle : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_style_new(Pango.Style style);
+		static d_pango_attr_style_new pango_attr_style_new = FuncLoader.LoadFunction<d_pango_attr_style_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_style_new"));
+
+		public AttrStyle (Pango.Style style) : this (pango_attr_style_new (style)) {}
+
+		internal AttrStyle (IntPtr raw) : base (raw) {}
+
+		public Pango.Style Style {
+			get {
+				return (Pango.Style) (AttrInt.New (Handle).Value);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrUnderline.cs

@@ -0,0 +1,40 @@
+// Pango.AttrUnderline - Pango.Attribute for Pango.Underline
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrUnderline : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_underline_new(Pango.Underline underline);
+		static d_pango_attr_underline_new pango_attr_underline_new = FuncLoader.LoadFunction<d_pango_attr_underline_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_underline_new"));
+
+		public AttrUnderline (Pango.Underline underline) : this (pango_attr_underline_new (underline)) {}
+
+		internal AttrUnderline (IntPtr raw) : base (raw) {}
+
+		public Pango.Underline Underline {
+			get {
+				return (Pango.Underline) (AttrInt.New (Handle).Value);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrUnderlineColor.cs

@@ -0,0 +1,42 @@
+// Pango.AttrUnderlineColor - Pango.Attribute for underline color
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrUnderlineColor : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_underline_color_new(ushort red, ushort green, ushort blue);
+		static d_pango_attr_underline_color_new pango_attr_underline_color_new = FuncLoader.LoadFunction<d_pango_attr_underline_color_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_underline_color_new"));
+
+		public AttrUnderlineColor (ushort red, ushort green, ushort blue) : this (pango_attr_underline_color_new (red, green, blue)) {}
+
+		public AttrUnderlineColor (Pango.Color color) : this (pango_attr_underline_color_new (color.Red, color.Green, color.Blue)) {}
+
+		internal AttrUnderlineColor (IntPtr raw) : base (raw) {}
+
+		public Pango.Color Color {
+			get {
+				return AttrColor.New (Handle).Color;
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrVariant.cs

@@ -0,0 +1,40 @@
+// Pango.AttrVariant - Pango.Attribute for Pango.Variant
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrVariant : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_variant_new(Pango.Variant variant);
+		static d_pango_attr_variant_new pango_attr_variant_new = FuncLoader.LoadFunction<d_pango_attr_variant_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_variant_new"));
+
+		public AttrVariant (Pango.Variant variant) : this (pango_attr_variant_new (variant)) {}
+
+		internal AttrVariant (IntPtr raw) : base (raw) {}
+
+		public Pango.Variant Variant {
+			get {
+				return (Pango.Variant) (AttrInt.New (Handle).Value);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/AttrWeight.cs

@@ -0,0 +1,40 @@
+// Pango.AttrWeight - Pango.Attribute for Pango.Weight
+//
+// Copyright (c) 2005 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class AttrWeight : Attribute {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_weight_new(Pango.Weight weight);
+		static d_pango_attr_weight_new pango_attr_weight_new = FuncLoader.LoadFunction<d_pango_attr_weight_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_weight_new"));
+
+		public AttrWeight (Pango.Weight weight) : this (pango_attr_weight_new (weight)) {}
+
+		internal AttrWeight (IntPtr raw) : base (raw) {}
+
+		public Pango.Weight Weight {
+			get {
+				return (Pango.Weight) (AttrInt.New (Handle).Value);
+			}
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/Attribute.cs

@@ -0,0 +1,167 @@
+// Pango.Attribute - Attribute "base class"
+//
+// Copyright (c) 2005, 2007, 2008 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public class Attribute : GLib.IWrapper, IDisposable {
+
+		IntPtr raw;
+
+		internal Attribute (IntPtr raw)
+		{
+			this.raw = raw;
+		}
+
+		static Pango.AttrType GetAttrType (IntPtr raw)
+		{
+			if (raw == IntPtr.Zero)
+				return AttrType.Invalid;
+			IntPtr klass = Marshal.ReadIntPtr (raw);
+			return (AttrType) Marshal.ReadInt32 (klass);
+		}
+
+		public static Attribute GetAttribute (IntPtr raw)
+		{
+			switch (GetAttrType (raw)) {
+			case Pango.AttrType.Language:
+				return new AttrLanguage (raw);
+			case Pango.AttrType.Family:
+				return new AttrFamily (raw);
+			case Pango.AttrType.Style:
+				return new AttrStyle (raw);
+			case Pango.AttrType.Weight:
+				return new AttrWeight (raw);
+			case Pango.AttrType.Variant:
+				return new AttrVariant (raw);
+			case Pango.AttrType.Stretch:
+				return new AttrStretch (raw);
+			case Pango.AttrType.Size:
+				return new AttrSize (raw);
+			case Pango.AttrType.FontDesc:
+				return new AttrFontDesc (raw);
+			case Pango.AttrType.Foreground:
+				return new AttrForeground (raw);
+			case Pango.AttrType.Background:
+				return new AttrBackground (raw);
+			case Pango.AttrType.Underline:
+				return new AttrUnderline (raw);
+			case Pango.AttrType.Strikethrough:
+				return new AttrStrikethrough (raw);
+			case Pango.AttrType.Rise:
+				return new AttrRise (raw);
+			case Pango.AttrType.Shape:
+				return new AttrShape (raw);
+			case Pango.AttrType.Scale:
+				return new AttrScale (raw);
+			case Pango.AttrType.Fallback:
+				return new AttrFallback (raw);
+			case Pango.AttrType.LetterSpacing:
+				return new AttrLetterSpacing (raw);
+			case Pango.AttrType.UnderlineColor:
+				return new AttrUnderlineColor (raw);
+			case Pango.AttrType.StrikethroughColor:
+				return new AttrStrikethroughColor (raw);
+			case Pango.AttrType.Gravity:
+				return new AttrGravity (raw);
+			case Pango.AttrType.GravityHint:
+				return new AttrGravityHint (raw);
+			default:
+				return new Attribute (raw);
+			}
+		}
+
+		~Attribute ()
+		{
+			Dispose ();
+		}
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_pango_attribute_destroy(IntPtr raw);
+		static d_pango_attribute_destroy pango_attribute_destroy = FuncLoader.LoadFunction<d_pango_attribute_destroy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attribute_destroy"));
+
+		public void Dispose ()
+		{
+			if (raw != IntPtr.Zero) {
+				pango_attribute_destroy (raw);
+				raw = IntPtr.Zero;
+			}
+			GC.SuppressFinalize (this);
+		}
+
+		public IntPtr Handle {
+			get {
+				return raw;
+			}
+		}
+
+		public static GLib.GType GType {
+			get {
+				return GLib.GType.Pointer;
+			}
+		}
+
+		public Pango.AttrType Type {
+			get { return GetAttrType (raw); }
+		}
+
+		internal struct NativeStruct {
+			IntPtr klass;
+			public uint start_index;
+			public uint end_index;
+		}
+
+		NativeStruct Native {
+			get { return (NativeStruct) Marshal.PtrToStructure (raw, typeof(NativeStruct)); }
+		}
+
+		public uint StartIndex {
+			get { return Native.start_index; }
+			set {
+				NativeStruct native = Native;
+				native.start_index = value;
+				Marshal.StructureToPtr (native, raw, false);
+			}
+		}
+
+		public uint EndIndex {
+			get { return Native.end_index; }
+			set {
+				NativeStruct native = Native;
+				native.end_index = value;
+				Marshal.StructureToPtr (native, raw, false);
+			}
+		}
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attribute_copy(IntPtr raw);
+		static d_pango_attribute_copy pango_attribute_copy = FuncLoader.LoadFunction<d_pango_attribute_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attribute_copy"));
+
+		public Pango.Attribute Copy () {
+			return GetAttribute (pango_attribute_copy (raw));
+		}
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate bool d_pango_attribute_equal(IntPtr raw1, IntPtr raw2);
+		static d_pango_attribute_equal pango_attribute_equal = FuncLoader.LoadFunction<d_pango_attribute_equal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attribute_equal"));
+
+		public bool Equal (Pango.Attribute attr2) {
+			return pango_attribute_equal (raw, attr2.raw);
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/Context.cs

@@ -0,0 +1,60 @@
+// Pango.Context.cs - Pango Context class customizations
+//
+// Authors:  Mike Kestner  <mkestner@ximian.com>
+//
+// Copyright (c) 2004 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public partial class Context {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_pango_context_list_families2(IntPtr raw, out IntPtr families, out int n_families);
+		static d_pango_context_list_families2 pango_context_list_families2 = FuncLoader.LoadFunction<d_pango_context_list_families2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_list_families"));
+
+		public FontFamily [] Families {
+			get {
+				int count;
+				IntPtr array_ptr;
+				pango_context_list_families2 (Handle, out array_ptr, out count);
+				if (array_ptr == IntPtr.Zero)
+					return new FontFamily [0];
+				FontFamily [] result = new FontFamily [count];
+				for (int i = 0; i < count; i++) {
+					IntPtr fam_ptr = Marshal.ReadIntPtr (array_ptr, i * IntPtr.Size);
+					result [i] = GLib.Object.GetObject (fam_ptr) as FontFamily;
+				}
+
+				GLib.Marshaller.Free (array_ptr);
+				return result;
+			}
+		}
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_pango_context_list_families(IntPtr raw, IntPtr families, out int n_families);
+		static d_pango_context_list_families pango_context_list_families = FuncLoader.LoadFunction<d_pango_context_list_families>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_list_families"));
+
+		[Obsolete]
+		public int ListFamilies(Pango.FontFamily families) {
+			int n_families;
+			pango_context_list_families(Handle, families.Handle, out n_families);
+			return n_families;
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/Coverage.cs

@@ -0,0 +1,42 @@
+// Pango.Coverage.cs - Pango Coverage class customizations
+//
+// Author: Mike Kestner <mkestner@ximian.com>
+//
+// Copyright (c) 2004 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public partial class Coverage {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_pango_coverage_to_bytes(IntPtr raw, out IntPtr bytes, out int n_bytes);
+		static d_pango_coverage_to_bytes pango_coverage_to_bytes = FuncLoader.LoadFunction<d_pango_coverage_to_bytes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_coverage_to_bytes"));
+
+		public void ToBytes(out byte[] bytes) 
+		{
+			int count;
+			IntPtr array_ptr;
+			pango_coverage_to_bytes (Handle, out array_ptr, out count);
+			bytes = new byte [count];
+			Marshal.Copy (array_ptr, bytes, 0, count);
+			GLib.Marshaller.Free (array_ptr);
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/FontFamily.cs

@@ -0,0 +1,60 @@
+// Pango.FontFamily.cs - Pango FontFamily class customizations
+//
+// Authors:  Mike Kestner  <mkestner@ximian.com>
+//
+// Copyright (c) 2004 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public partial class FontFamily {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_pango_font_family_list_faces2(IntPtr raw, out IntPtr faces, out int n_faces);
+		static d_pango_font_family_list_faces2 pango_font_family_list_faces2 = FuncLoader.LoadFunction<d_pango_font_family_list_faces2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_family_list_faces"));
+
+		public FontFace [] Faces {
+			get {
+				int count;
+				IntPtr array_ptr;
+				pango_font_family_list_faces2 (Handle, out array_ptr, out count);
+				if (array_ptr == IntPtr.Zero)
+					return new FontFace [0];
+				FontFace [] result = new FontFace [count];
+				for (int i = 0; i < count; i++) {
+					IntPtr fam_ptr = Marshal.ReadIntPtr (array_ptr, i * IntPtr.Size);
+					result [i] = GLib.Object.GetObject (fam_ptr) as FontFace;
+				}
+
+				GLib.Marshaller.Free (array_ptr);
+				return result;
+			}
+		}
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_pango_font_family_list_faces(IntPtr raw, IntPtr faces, out int n_faces);
+		static d_pango_font_family_list_faces pango_font_family_list_faces = FuncLoader.LoadFunction<d_pango_font_family_list_faces>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_family_list_faces"));
+
+		[Obsolete]
+		public int ListFaces(Pango.FontFace faces) {
+			int n_faces;
+			pango_font_family_list_faces(Handle, faces.Handle, out n_faces);
+			return n_faces;
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/FontMap.cs

@@ -0,0 +1,60 @@
+// Pango.FontMap.cs - Pango FontMap class customizations
+//
+// Authors:  Mike Kestner  <mkestner@ximian.com>
+//
+// Copyright (c) 2004 Novell, Inc.
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of version 2 of the Lesser GNU General 
+// Public License as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+	public partial class FontMap {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_pango_font_map_list_families2(IntPtr raw, out IntPtr families, out int n_families);
+		static d_pango_font_map_list_families2 pango_font_map_list_families2 = FuncLoader.LoadFunction<d_pango_font_map_list_families2>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_map_list_families"));
+
+		public FontFamily [] Families {
+			get {
+				int count;
+				IntPtr array_ptr;
+				pango_font_map_list_families2 (Handle, out array_ptr, out count);
+				if (array_ptr == IntPtr.Zero)
+					return new FontFamily [0];
+				FontFamily [] result = new FontFamily [count];
+				for (int i = 0; i < count; i++) {
+					IntPtr fam_ptr = Marshal.ReadIntPtr (array_ptr, i * IntPtr.Size);
+					result [i] = GLib.Object.GetObject (fam_ptr) as FontFamily;
+				}
+
+				GLib.Marshaller.Free (array_ptr);
+				return result;
+			}
+		}
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		delegate void d_pango_font_map_list_families(IntPtr raw, IntPtr families, out int n_families);
+		static d_pango_font_map_list_families pango_font_map_list_families = FuncLoader.LoadFunction<d_pango_font_map_list_families>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_map_list_families"));
+
+		[Obsolete]
+		public int ListFamilies(Pango.FontFamily families) {
+			int n_families;
+			pango_font_map_list_families(Handle, families.Handle, out n_families);
+			return n_families;
+		}
+	}
+}
+

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/Alignment.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Pango.AlignmentGType))]
+	public enum Alignment {
+
+		Left,
+		Center,
+		Right,
+	}
+
+	internal class AlignmentGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_alignment_get_type();
+		static d_pango_alignment_get_type pango_alignment_get_type = FuncLoader.LoadFunction<d_pango_alignment_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_alignment_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (pango_alignment_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/Analysis.cs

@@ -0,0 +1,85 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct Analysis : IEquatable<Analysis> {
+
+		private IntPtr _shape_engine;
+		public Pango.EngineShape ShapeEngine {
+			get {
+				return _shape_engine == IntPtr.Zero ? null : (Pango.EngineShape) GLib.Opaque.GetOpaque (_shape_engine, typeof (Pango.EngineShape), false);
+			}
+			set {
+				_shape_engine = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		private IntPtr _lang_engine;
+		public Pango.EngineLang LangEngine {
+			get {
+				return _lang_engine == IntPtr.Zero ? null : (Pango.EngineLang) GLib.Opaque.GetOpaque (_lang_engine, typeof (Pango.EngineLang), false);
+			}
+			set {
+				_lang_engine = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		private IntPtr _font;
+		public Pango.Font Font {
+			get {
+				return GLib.Object.GetObject(_font) as Pango.Font;
+			}
+			set {
+				_font = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		public byte Level;
+		public byte Gravity;
+		public byte Flags;
+		public byte Script;
+		private IntPtr _language;
+		public Pango.Language Language {
+			get {
+				return _language == IntPtr.Zero ? null : (Pango.Language) GLib.Opaque.GetOpaque (_language, typeof (Pango.Language), false);
+			}
+			set {
+				_language = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		private IntPtr _extra_attrs;
+
+		public static Pango.Analysis Zero = new Pango.Analysis ();
+
+		public static Pango.Analysis New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Pango.Analysis.Zero;
+			return (Pango.Analysis) Marshal.PtrToStructure (raw, typeof (Pango.Analysis));
+		}
+
+		public bool Equals (Analysis other)
+		{
+			return true && ShapeEngine.Equals (other.ShapeEngine) && LangEngine.Equals (other.LangEngine) && Font.Equals (other.Font) && Level.Equals (other.Level) && Gravity.Equals (other.Gravity) && Flags.Equals (other.Flags) && Script.Equals (other.Script) && Language.Equals (other.Language) && _extra_attrs.Equals (other._extra_attrs);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is Analysis && Equals ((Analysis) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ ShapeEngine.GetHashCode () ^ LangEngine.GetHashCode () ^ Font.GetHashCode () ^ Level.GetHashCode () ^ Gravity.GetHashCode () ^ Flags.GetHashCode () ^ Script.GetHashCode () ^ Language.GetHashCode () ^ _extra_attrs.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/AttrDataCopyFunc.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+
+	public delegate IntPtr AttrDataCopyFunc();
+
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/AttrFilterFunc.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+
+	public delegate bool AttrFilterFunc(Pango.Attribute attribute);
+
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/AttrFontFeatures.cs

@@ -0,0 +1,98 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class AttrFontFeatures : GLib.Opaque {
+
+		public Pango.Attribute Attr {
+			get {
+				unsafe {
+					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("attr"));
+					return Pango.Attribute.GetAttribute ((*raw_ptr));
+				}
+			}
+			set {
+				unsafe {
+					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("attr"));
+					*raw_ptr = value.Handle;
+				}
+			}
+		}
+
+		public string Features {
+			get {
+				unsafe {
+					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("features"));
+					return GLib.Marshaller.Utf8PtrToString ((*raw_ptr));
+				}
+			}
+			set {
+				unsafe {
+					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("features"));
+					*raw_ptr = GLib.Marshaller.StringToPtrGStrdup (value);
+				}
+			}
+		}
+
+		public AttrFontFeatures(IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_font_features_new(IntPtr features);
+		static d_pango_attr_font_features_new pango_attr_font_features_new = FuncLoader.LoadFunction<d_pango_attr_font_features_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_font_features_new"));
+
+		public AttrFontFeatures (string features) 
+		{
+			IntPtr native_features = GLib.Marshaller.StringToPtrGStrdup (features);
+			Raw = pango_attr_font_features_new(native_features);
+			GLib.Marshaller.Free (native_features);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("attr"
+							, 0
+							, (uint) Marshal.SizeOf<Pango.Attribute>() // attr
+							, null
+							, "features"
+							, (long) Marshal.OffsetOf<PangoAttrFontFeatures_attrAlign>("attr")
+							, 0
+							),
+						new GLib.AbiField("features"
+							, -1
+							, (uint) sizeof( IntPtr ) // features
+							, "attr"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct PangoAttrFontFeatures_attrAlign
+		{
+			sbyte f1;
+			private Pango.Attribute attr;
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/AttrIterator.cs

@@ -0,0 +1,109 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class AttrIterator : GLib.Opaque {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_iterator_copy(IntPtr raw);
+		static d_pango_attr_iterator_copy pango_attr_iterator_copy = FuncLoader.LoadFunction<d_pango_attr_iterator_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_iterator_copy"));
+
+		public Pango.AttrIterator Copy() {
+			IntPtr raw_ret = pango_attr_iterator_copy(Handle);
+			Pango.AttrIterator ret = raw_ret == IntPtr.Zero ? null : (Pango.AttrIterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.AttrIterator), true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_iterator_get(IntPtr raw, int type);
+		static d_pango_attr_iterator_get pango_attr_iterator_get = FuncLoader.LoadFunction<d_pango_attr_iterator_get>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_iterator_get"));
+
+		public Pango.Attribute Get(Pango.AttrType type) {
+			IntPtr raw_ret = pango_attr_iterator_get(Handle, (int) type);
+			Pango.Attribute ret = Pango.Attribute.GetAttribute (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_attr_iterator_next(IntPtr raw);
+		static d_pango_attr_iterator_next pango_attr_iterator_next = FuncLoader.LoadFunction<d_pango_attr_iterator_next>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_iterator_next"));
+
+		public bool Next() {
+			bool raw_ret = pango_attr_iterator_next(Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_attr_iterator_range(IntPtr raw, out int start, out int end);
+		static d_pango_attr_iterator_range pango_attr_iterator_range = FuncLoader.LoadFunction<d_pango_attr_iterator_range>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_iterator_range"));
+
+		public void Range(out int start, out int end) {
+			pango_attr_iterator_range(Handle, out start, out end);
+		}
+
+		public AttrIterator(IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_attr_iterator_destroy(IntPtr raw);
+		static d_pango_attr_iterator_destroy pango_attr_iterator_destroy = FuncLoader.LoadFunction<d_pango_attr_iterator_destroy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_iterator_destroy"));
+
+		protected override void Free (IntPtr raw)
+		{
+			pango_attr_iterator_destroy (raw);
+		}
+
+		[Obsolete("Pango.AttrIterator is now freed automatically")]
+		public void Destroy () {}
+
+		class FinalizerInfo {
+			IntPtr handle;
+			public uint timeoutHandlerId;
+
+			public FinalizerInfo (IntPtr handle)
+			{
+				this.handle = handle;
+			}
+
+			public bool Handler ()
+			{
+				pango_attr_iterator_destroy (handle);
+				GLib.Timeout.Remove(timeoutHandlerId);
+				return false;
+			}
+		}
+
+		~AttrIterator ()
+		{
+			if (!Owned)
+				return;
+			FinalizerInfo info = new FinalizerInfo (Handle);
+			info.timeoutHandlerId = GLib.Timeout.Add (50, new GLib.TimeoutHandler (info.Handler));
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/AttrList.cs

@@ -0,0 +1,151 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class AttrList : GLib.Opaque {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_list_copy(IntPtr raw);
+		static d_pango_attr_list_copy pango_attr_list_copy = FuncLoader.LoadFunction<d_pango_attr_list_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_list_copy"));
+
+		public Pango.AttrList Copy() {
+			IntPtr raw_ret = pango_attr_list_copy(Handle);
+			Pango.AttrList ret = raw_ret == IntPtr.Zero ? null : (Pango.AttrList) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.AttrList), true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_list_filter(IntPtr raw, PangoSharp.AttrFilterFuncNative func, IntPtr data);
+		static d_pango_attr_list_filter pango_attr_list_filter = FuncLoader.LoadFunction<d_pango_attr_list_filter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_list_filter"));
+
+		public Pango.AttrList Filter(Pango.AttrFilterFunc func) {
+			PangoSharp.AttrFilterFuncWrapper func_wrapper = new PangoSharp.AttrFilterFuncWrapper (func);
+			IntPtr raw_ret = pango_attr_list_filter(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
+			Pango.AttrList ret = raw_ret == IntPtr.Zero ? null : (Pango.AttrList) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.AttrList), false);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_list_get_iterator(IntPtr raw);
+		static d_pango_attr_list_get_iterator pango_attr_list_get_iterator = FuncLoader.LoadFunction<d_pango_attr_list_get_iterator>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_list_get_iterator"));
+
+		public Pango.AttrIterator Iterator { 
+			get {
+				IntPtr raw_ret = pango_attr_list_get_iterator(Handle);
+				Pango.AttrIterator ret = raw_ret == IntPtr.Zero ? null : (Pango.AttrIterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.AttrIterator), true);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_list_get_type();
+		static d_pango_attr_list_get_type pango_attr_list_get_type = FuncLoader.LoadFunction<d_pango_attr_list_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_list_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_attr_list_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_attr_list_splice(IntPtr raw, IntPtr other, int pos, int len);
+		static d_pango_attr_list_splice pango_attr_list_splice = FuncLoader.LoadFunction<d_pango_attr_list_splice>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_list_splice"));
+
+		public void Splice(Pango.AttrList other, int pos, int len) {
+			pango_attr_list_splice(Handle, other == null ? IntPtr.Zero : other.Handle, pos, len);
+		}
+
+		public AttrList(IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_list_new();
+		static d_pango_attr_list_new pango_attr_list_new = FuncLoader.LoadFunction<d_pango_attr_list_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_list_new"));
+
+		public AttrList () 
+		{
+			Raw = pango_attr_list_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_list_ref(IntPtr raw);
+		static d_pango_attr_list_ref pango_attr_list_ref = FuncLoader.LoadFunction<d_pango_attr_list_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_list_ref"));
+
+		protected override void Ref (IntPtr raw)
+		{
+			if (!Owned) {
+				pango_attr_list_ref (raw);
+				Owned = true;
+			}
+		}
+
+		[Obsolete("Pango.AttrList is now refcounted automatically")]
+		public AttrList Ref () { return this; }
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_attr_list_unref(IntPtr raw);
+		static d_pango_attr_list_unref pango_attr_list_unref = FuncLoader.LoadFunction<d_pango_attr_list_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_list_unref"));
+
+		protected override void Unref (IntPtr raw)
+		{
+			if (Owned) {
+				pango_attr_list_unref (raw);
+				Owned = false;
+			}
+		}
+
+		[Obsolete("Pango.AttrList is now refcounted automatically")]
+		public void Unref () {}
+
+		class FinalizerInfo {
+			IntPtr handle;
+			public uint timeoutHandlerId;
+
+			public FinalizerInfo (IntPtr handle)
+			{
+				this.handle = handle;
+			}
+
+			public bool Handler ()
+			{
+				pango_attr_list_unref (handle);
+				GLib.Timeout.Remove(timeoutHandlerId);
+				return false;
+			}
+		}
+
+		~AttrList ()
+		{
+			if (!Owned)
+				return;
+			FinalizerInfo info = new FinalizerInfo (Handle);
+			info.timeoutHandlerId = GLib.Timeout.Add (50, new GLib.TimeoutHandler (info.Handler));
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/AttrType.cs

@@ -0,0 +1,53 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Pango.AttrTypeGType))]
+	public enum AttrType {
+
+		Invalid,
+		Language,
+		Family,
+		Style,
+		Weight,
+		Variant,
+		Stretch,
+		Size,
+		FontDesc,
+		Foreground,
+		Background,
+		Underline,
+		Strikethrough,
+		Rise,
+		Shape,
+		Scale,
+		Fallback,
+		LetterSpacing,
+		UnderlineColor,
+		StrikethroughColor,
+		AbsoluteSize,
+		Gravity,
+		GravityHint,
+		FontFeatures,
+		ForegroundAlpha,
+		BackgroundAlpha,
+	}
+
+	internal class AttrTypeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_attr_type_get_type();
+		static d_pango_attr_type_get_type pango_attr_type_get_type = FuncLoader.LoadFunction<d_pango_attr_type_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_attr_type_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (pango_attr_type_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/BidiType.cs

@@ -0,0 +1,46 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Pango.BidiTypeGType))]
+	public enum BidiType {
+
+		L,
+		Lre,
+		Lro,
+		R,
+		Al,
+		Rle,
+		Rlo,
+		Pdf,
+		En,
+		Es,
+		Et,
+		An,
+		Cs,
+		Nsm,
+		Bn,
+		B,
+		S,
+		Ws,
+		On,
+	}
+
+	internal class BidiTypeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_bidi_type_get_type();
+		static d_pango_bidi_type_get_type pango_bidi_type_get_type = FuncLoader.LoadFunction<d_pango_bidi_type_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_bidi_type_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (pango_bidi_type_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/BlockInfo.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class BlockInfo : GLib.Opaque {
+
+		public BlockInfo(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CacheEntry.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CacheEntry : GLib.Opaque {
+
+		public CacheEntry(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CairoContextInfo.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CairoContextInfo : GLib.Opaque {
+
+		public CairoContextInfo(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CairoFcFont.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CairoFcFont : GLib.Opaque {
+
+		public CairoFcFont(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CairoFcFontClass.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CairoFcFontClass : GLib.Opaque {
+
+		public CairoFcFontClass(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CairoFcFontMapClass.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CairoFcFontMapClass : GLib.Opaque {
+
+		public CairoFcFontMapClass(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CairoHelper.cs

@@ -0,0 +1,172 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CairoHelper {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_pango_cairo_context_get_resolution(IntPtr context);
+		static d_pango_cairo_context_get_resolution pango_cairo_context_get_resolution = FuncLoader.LoadFunction<d_pango_cairo_context_get_resolution>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_context_get_resolution"));
+
+		public static double ContextGetResolution(Pango.Context context) {
+			double raw_ret = pango_cairo_context_get_resolution(context == null ? IntPtr.Zero : context.Handle);
+			double ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate PangoSharp.CairoShapeRendererFuncNative d_pango_cairo_context_get_shape_renderer(IntPtr context, IntPtr data);
+		static d_pango_cairo_context_get_shape_renderer pango_cairo_context_get_shape_renderer = FuncLoader.LoadFunction<d_pango_cairo_context_get_shape_renderer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_context_get_shape_renderer"));
+
+		public static Pango.CairoShapeRendererFunc ContextGetShapeRenderer(Pango.Context context, IntPtr data) {
+			PangoSharp.CairoShapeRendererFuncNative raw_ret = pango_cairo_context_get_shape_renderer(context == null ? IntPtr.Zero : context.Handle, data);
+			Pango.CairoShapeRendererFunc ret = PangoSharp.CairoShapeRendererFuncWrapper.GetManagedDelegate (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_context_set_resolution(IntPtr context, double dpi);
+		static d_pango_cairo_context_set_resolution pango_cairo_context_set_resolution = FuncLoader.LoadFunction<d_pango_cairo_context_set_resolution>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_context_set_resolution"));
+
+		public static void ContextSetResolution(Pango.Context context, double dpi) {
+			pango_cairo_context_set_resolution(context == null ? IntPtr.Zero : context.Handle, dpi);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_context_set_shape_renderer(IntPtr context, PangoSharp.CairoShapeRendererFuncNative func, IntPtr data, GLib.DestroyNotify dnotify);
+		static d_pango_cairo_context_set_shape_renderer pango_cairo_context_set_shape_renderer = FuncLoader.LoadFunction<d_pango_cairo_context_set_shape_renderer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_context_set_shape_renderer"));
+
+		public static void ContextSetShapeRenderer(Pango.Context context, Pango.CairoShapeRendererFunc func) {
+			PangoSharp.CairoShapeRendererFuncWrapper func_wrapper = new PangoSharp.CairoShapeRendererFuncWrapper (func);
+			IntPtr data;
+			GLib.DestroyNotify dnotify;
+			if (func == null) {
+				data = IntPtr.Zero;
+				dnotify = null;
+			} else {
+				data = (IntPtr) GCHandle.Alloc (func_wrapper);
+				dnotify = GLib.DestroyHelper.NotifyHandler;
+			}
+			pango_cairo_context_set_shape_renderer(context == null ? IntPtr.Zero : context.Handle, func_wrapper.NativeDelegate, data, dnotify);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_cairo_create_context(IntPtr cr);
+		static d_pango_cairo_create_context pango_cairo_create_context = FuncLoader.LoadFunction<d_pango_cairo_create_context>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_create_context"));
+
+		public static Pango.Context CreateContext(Cairo.Context cr) {
+			IntPtr raw_ret = pango_cairo_create_context(cr == null ? IntPtr.Zero : cr.Handle);
+			Pango.Context ret = GLib.Object.GetObject(raw_ret, true) as Pango.Context;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_cairo_create_layout(IntPtr cr);
+		static d_pango_cairo_create_layout pango_cairo_create_layout = FuncLoader.LoadFunction<d_pango_cairo_create_layout>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_create_layout"));
+
+		public static Pango.Layout CreateLayout(Cairo.Context cr) {
+			IntPtr raw_ret = pango_cairo_create_layout(cr == null ? IntPtr.Zero : cr.Handle);
+			Pango.Layout ret = GLib.Object.GetObject(raw_ret, true) as Pango.Layout;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_error_underline_path(IntPtr cr, double x, double y, double width, double height);
+		static d_pango_cairo_error_underline_path pango_cairo_error_underline_path = FuncLoader.LoadFunction<d_pango_cairo_error_underline_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_error_underline_path"));
+
+		public static void ErrorUnderlinePath(Cairo.Context cr, double x, double y, double width, double height) {
+			pango_cairo_error_underline_path(cr == null ? IntPtr.Zero : cr.Handle, x, y, width, height);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_glyph_string_path(IntPtr cr, IntPtr font, IntPtr glyphs);
+		static d_pango_cairo_glyph_string_path pango_cairo_glyph_string_path = FuncLoader.LoadFunction<d_pango_cairo_glyph_string_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_glyph_string_path"));
+
+		public static void GlyphStringPath(Cairo.Context cr, Pango.Font font, Pango.GlyphString glyphs) {
+			pango_cairo_glyph_string_path(cr == null ? IntPtr.Zero : cr.Handle, font == null ? IntPtr.Zero : font.Handle, glyphs == null ? IntPtr.Zero : glyphs.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_layout_line_path(IntPtr cr, IntPtr line);
+		static d_pango_cairo_layout_line_path pango_cairo_layout_line_path = FuncLoader.LoadFunction<d_pango_cairo_layout_line_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_layout_line_path"));
+
+		public static void LayoutLinePath(Cairo.Context cr, Pango.LayoutLine line) {
+			pango_cairo_layout_line_path(cr == null ? IntPtr.Zero : cr.Handle, line == null ? IntPtr.Zero : line.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_layout_path(IntPtr cr, IntPtr layout);
+		static d_pango_cairo_layout_path pango_cairo_layout_path = FuncLoader.LoadFunction<d_pango_cairo_layout_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_layout_path"));
+
+		public static void LayoutPath(Cairo.Context cr, Pango.Layout layout) {
+			pango_cairo_layout_path(cr == null ? IntPtr.Zero : cr.Handle, layout == null ? IntPtr.Zero : layout.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_show_error_underline(IntPtr cr, double x, double y, double width, double height);
+		static d_pango_cairo_show_error_underline pango_cairo_show_error_underline = FuncLoader.LoadFunction<d_pango_cairo_show_error_underline>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_show_error_underline"));
+
+		public static void ShowErrorUnderline(Cairo.Context cr, double x, double y, double width, double height) {
+			pango_cairo_show_error_underline(cr == null ? IntPtr.Zero : cr.Handle, x, y, width, height);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_show_glyph_item(IntPtr cr, IntPtr text, IntPtr glyph_item);
+		static d_pango_cairo_show_glyph_item pango_cairo_show_glyph_item = FuncLoader.LoadFunction<d_pango_cairo_show_glyph_item>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_show_glyph_item"));
+
+		public static void ShowGlyphItem(Cairo.Context cr, string text, Pango.GlyphItem glyph_item) {
+			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
+			IntPtr native_glyph_item = GLib.Marshaller.StructureToPtrAlloc (glyph_item);
+			pango_cairo_show_glyph_item(cr == null ? IntPtr.Zero : cr.Handle, native_text, native_glyph_item);
+			GLib.Marshaller.Free (native_text);
+			Marshal.FreeHGlobal (native_glyph_item);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_show_glyph_string(IntPtr cr, IntPtr font, IntPtr glyphs);
+		static d_pango_cairo_show_glyph_string pango_cairo_show_glyph_string = FuncLoader.LoadFunction<d_pango_cairo_show_glyph_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_show_glyph_string"));
+
+		public static void ShowGlyphString(Cairo.Context cr, Pango.Font font, Pango.GlyphString glyphs) {
+			pango_cairo_show_glyph_string(cr == null ? IntPtr.Zero : cr.Handle, font == null ? IntPtr.Zero : font.Handle, glyphs == null ? IntPtr.Zero : glyphs.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_show_layout(IntPtr cr, IntPtr layout);
+		static d_pango_cairo_show_layout pango_cairo_show_layout = FuncLoader.LoadFunction<d_pango_cairo_show_layout>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_show_layout"));
+
+		public static void ShowLayout(Cairo.Context cr, Pango.Layout layout) {
+			pango_cairo_show_layout(cr == null ? IntPtr.Zero : cr.Handle, layout == null ? IntPtr.Zero : layout.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_show_layout_line(IntPtr cr, IntPtr line);
+		static d_pango_cairo_show_layout_line pango_cairo_show_layout_line = FuncLoader.LoadFunction<d_pango_cairo_show_layout_line>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_show_layout_line"));
+
+		public static void ShowLayoutLine(Cairo.Context cr, Pango.LayoutLine line) {
+			pango_cairo_show_layout_line(cr == null ? IntPtr.Zero : cr.Handle, line == null ? IntPtr.Zero : line.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_update_context(IntPtr cr, IntPtr context);
+		static d_pango_cairo_update_context pango_cairo_update_context = FuncLoader.LoadFunction<d_pango_cairo_update_context>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_update_context"));
+
+		public static void UpdateContext(Cairo.Context cr, Pango.Context context) {
+			pango_cairo_update_context(cr == null ? IntPtr.Zero : cr.Handle, context == null ? IntPtr.Zero : context.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_cairo_update_layout(IntPtr cr, IntPtr layout);
+		static d_pango_cairo_update_layout pango_cairo_update_layout = FuncLoader.LoadFunction<d_pango_cairo_update_layout>(FuncLoader.GetProcAddress(GLibrary.Load(Library.PangoCairo), "pango_cairo_update_layout"));
+
+		public static void UpdateLayout(Cairo.Context cr, Pango.Layout layout) {
+			pango_cairo_update_layout(cr == null ? IntPtr.Zero : cr.Handle, layout == null ? IntPtr.Zero : layout.Handle);
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CairoRendererClass.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CairoRendererClass : GLib.Opaque {
+
+		public CairoRendererClass(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CairoShapeRendererFunc.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+
+	public delegate void CairoShapeRendererFunc(Cairo.Context cr, Pango.Attribute attr, bool do_path);
+
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CairoWin32Font.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CairoWin32Font : GLib.Opaque {
+
+		public CairoWin32Font(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CairoWin32FontClass.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CairoWin32FontClass : GLib.Opaque {
+
+		public CairoWin32FontClass(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CairoWin32FontMapClass.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CairoWin32FontMapClass : GLib.Opaque {
+
+		public CairoWin32FontMapClass(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/Color.cs

@@ -0,0 +1,108 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct Color : IEquatable<Color> {
+
+		public ushort Red;
+		public ushort Green;
+		public ushort Blue;
+
+		public static Pango.Color Zero = new Pango.Color ();
+
+		public static Pango.Color New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Pango.Color.Zero;
+			return (Pango.Color) Marshal.PtrToStructure (raw, typeof (Pango.Color));
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_color_get_type();
+		static d_pango_color_get_type pango_color_get_type = FuncLoader.LoadFunction<d_pango_color_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_color_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_color_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_color_parse(IntPtr raw, IntPtr spec);
+		static d_pango_color_parse pango_color_parse = FuncLoader.LoadFunction<d_pango_color_parse>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_color_parse"));
+
+		public bool Parse(string spec) {
+			IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<Pango.Color>());
+			System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+			IntPtr native_spec = GLib.Marshaller.StringToPtrGStrdup (spec);
+			bool raw_ret = pango_color_parse(this_as_native, native_spec);
+			bool ret = raw_ret;
+			ReadNative (this_as_native, ref this);
+			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+			GLib.Marshaller.Free (native_spec);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_color_to_string(IntPtr raw);
+		static d_pango_color_to_string pango_color_to_string = FuncLoader.LoadFunction<d_pango_color_to_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_color_to_string"));
+
+		public override string ToString() {
+			IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<Pango.Color>());
+			System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+			IntPtr raw_ret = pango_color_to_string(this_as_native);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			ReadNative (this_as_native, ref this);
+			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+			return ret;
+		}
+
+		static void ReadNative (IntPtr native, ref Pango.Color target)
+		{
+			target = New (native);
+		}
+
+		public bool Equals (Color other)
+		{
+			return true && Red.Equals (other.Red) && Green.Equals (other.Green) && Blue.Equals (other.Blue);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is Color && Equals ((Color) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ Red.GetHashCode () ^ Green.GetHashCode () ^ Blue.GetHashCode ();
+		}
+
+		public static explicit operator GLib.Value (Pango.Color boxed)
+		{
+			GLib.Value val = GLib.Value.Empty;
+			val.Init (Pango.Color.GType);
+			val.Val = boxed;
+			return val;
+		}
+
+		public static explicit operator Pango.Color (GLib.Value val)
+		{
+			return (Pango.Color) val.Val;
+		}
+
+		[Obsolete("This is a no-op")]
+		public Pango.Color Copy() {
+			return this;
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/Context.cs

@@ -0,0 +1,271 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Context : GLib.Object {
+
+		public Context (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_context_new();
+		static d_pango_context_new pango_context_new = FuncLoader.LoadFunction<d_pango_context_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_new"));
+
+		public Context () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Context)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = pango_context_new();
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (GLib.Object.class_abi.Fields);
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_context_changed(IntPtr raw);
+		static d_pango_context_changed pango_context_changed = FuncLoader.LoadFunction<d_pango_context_changed>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_changed"));
+
+		public void Changed() {
+			pango_context_changed(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_context_get_base_dir(IntPtr raw);
+		static d_pango_context_get_base_dir pango_context_get_base_dir = FuncLoader.LoadFunction<d_pango_context_get_base_dir>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_get_base_dir"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_context_set_base_dir(IntPtr raw, int direction);
+		static d_pango_context_set_base_dir pango_context_set_base_dir = FuncLoader.LoadFunction<d_pango_context_set_base_dir>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_set_base_dir"));
+
+		public Pango.Direction BaseDir { 
+			get {
+				int raw_ret = pango_context_get_base_dir(Handle);
+				Pango.Direction ret = (Pango.Direction) raw_ret;
+				return ret;
+			}
+			set {
+				pango_context_set_base_dir(Handle, (int) value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_context_get_base_gravity(IntPtr raw);
+		static d_pango_context_get_base_gravity pango_context_get_base_gravity = FuncLoader.LoadFunction<d_pango_context_get_base_gravity>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_get_base_gravity"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_context_set_base_gravity(IntPtr raw, int gravity);
+		static d_pango_context_set_base_gravity pango_context_set_base_gravity = FuncLoader.LoadFunction<d_pango_context_set_base_gravity>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_set_base_gravity"));
+
+		public Pango.Gravity BaseGravity { 
+			get {
+				int raw_ret = pango_context_get_base_gravity(Handle);
+				Pango.Gravity ret = (Pango.Gravity) raw_ret;
+				return ret;
+			}
+			set {
+				pango_context_set_base_gravity(Handle, (int) value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_context_get_font_description(IntPtr raw);
+		static d_pango_context_get_font_description pango_context_get_font_description = FuncLoader.LoadFunction<d_pango_context_get_font_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_get_font_description"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_context_set_font_description(IntPtr raw, IntPtr desc);
+		static d_pango_context_set_font_description pango_context_set_font_description = FuncLoader.LoadFunction<d_pango_context_set_font_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_set_font_description"));
+
+		public Pango.FontDescription FontDescription { 
+			get {
+				IntPtr raw_ret = pango_context_get_font_description(Handle);
+				Pango.FontDescription ret = raw_ret == IntPtr.Zero ? null : (Pango.FontDescription) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.FontDescription), false);
+				return ret;
+			}
+			set {
+				pango_context_set_font_description(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_context_get_font_map(IntPtr raw);
+		static d_pango_context_get_font_map pango_context_get_font_map = FuncLoader.LoadFunction<d_pango_context_get_font_map>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_get_font_map"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_context_set_font_map(IntPtr raw, IntPtr font_map);
+		static d_pango_context_set_font_map pango_context_set_font_map = FuncLoader.LoadFunction<d_pango_context_set_font_map>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_set_font_map"));
+
+		public Pango.FontMap FontMap { 
+			get {
+				IntPtr raw_ret = pango_context_get_font_map(Handle);
+				Pango.FontMap ret = GLib.Object.GetObject(raw_ret) as Pango.FontMap;
+				return ret;
+			}
+			set {
+				pango_context_set_font_map(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_context_get_gravity(IntPtr raw);
+		static d_pango_context_get_gravity pango_context_get_gravity = FuncLoader.LoadFunction<d_pango_context_get_gravity>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_get_gravity"));
+
+		public Pango.Gravity Gravity { 
+			get {
+				int raw_ret = pango_context_get_gravity(Handle);
+				Pango.Gravity ret = (Pango.Gravity) raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_context_get_gravity_hint(IntPtr raw);
+		static d_pango_context_get_gravity_hint pango_context_get_gravity_hint = FuncLoader.LoadFunction<d_pango_context_get_gravity_hint>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_get_gravity_hint"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_context_set_gravity_hint(IntPtr raw, int hint);
+		static d_pango_context_set_gravity_hint pango_context_set_gravity_hint = FuncLoader.LoadFunction<d_pango_context_set_gravity_hint>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_set_gravity_hint"));
+
+		public Pango.GravityHint GravityHint { 
+			get {
+				int raw_ret = pango_context_get_gravity_hint(Handle);
+				Pango.GravityHint ret = (Pango.GravityHint) raw_ret;
+				return ret;
+			}
+			set {
+				pango_context_set_gravity_hint(Handle, (int) value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_context_get_language(IntPtr raw);
+		static d_pango_context_get_language pango_context_get_language = FuncLoader.LoadFunction<d_pango_context_get_language>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_get_language"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_context_set_language(IntPtr raw, IntPtr language);
+		static d_pango_context_set_language pango_context_set_language = FuncLoader.LoadFunction<d_pango_context_set_language>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_set_language"));
+
+		public Pango.Language Language { 
+			get {
+				IntPtr raw_ret = pango_context_get_language(Handle);
+				Pango.Language ret = raw_ret == IntPtr.Zero ? null : (Pango.Language) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.Language), false);
+				return ret;
+			}
+			set {
+				pango_context_set_language(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_context_get_matrix(IntPtr raw);
+		static d_pango_context_get_matrix pango_context_get_matrix = FuncLoader.LoadFunction<d_pango_context_get_matrix>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_get_matrix"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_context_set_matrix(IntPtr raw, IntPtr value);
+		static d_pango_context_set_matrix pango_context_set_matrix = FuncLoader.LoadFunction<d_pango_context_set_matrix>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_set_matrix"));
+
+		public Pango.Matrix Matrix { 
+			get {
+				IntPtr raw_ret = pango_context_get_matrix(Handle);
+				Pango.Matrix ret = Pango.Matrix.New (raw_ret);
+				return ret;
+			}
+			set {
+				IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+				pango_context_set_matrix(Handle, native_value);
+				Marshal.FreeHGlobal (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_context_get_metrics(IntPtr raw, IntPtr desc, IntPtr language);
+		static d_pango_context_get_metrics pango_context_get_metrics = FuncLoader.LoadFunction<d_pango_context_get_metrics>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_get_metrics"));
+
+		public Pango.FontMetrics GetMetrics(Pango.FontDescription desc, Pango.Language language) {
+			IntPtr raw_ret = pango_context_get_metrics(Handle, desc == null ? IntPtr.Zero : desc.Handle, language == null ? IntPtr.Zero : language.Handle);
+			Pango.FontMetrics ret = raw_ret == IntPtr.Zero ? null : (Pango.FontMetrics) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.FontMetrics), false);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_pango_context_get_serial(IntPtr raw);
+		static d_pango_context_get_serial pango_context_get_serial = FuncLoader.LoadFunction<d_pango_context_get_serial>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_get_serial"));
+
+		public uint Serial { 
+			get {
+				uint raw_ret = pango_context_get_serial(Handle);
+				uint ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_context_get_type();
+		static d_pango_context_get_type pango_context_get_type = FuncLoader.LoadFunction<d_pango_context_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_context_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_context_load_font(IntPtr raw, IntPtr desc);
+		static d_pango_context_load_font pango_context_load_font = FuncLoader.LoadFunction<d_pango_context_load_font>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_load_font"));
+
+		public Pango.Font LoadFont(Pango.FontDescription desc) {
+			IntPtr raw_ret = pango_context_load_font(Handle, desc == null ? IntPtr.Zero : desc.Handle);
+			Pango.Font ret = GLib.Object.GetObject(raw_ret) as Pango.Font;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_context_load_fontset(IntPtr raw, IntPtr desc, IntPtr language);
+		static d_pango_context_load_fontset pango_context_load_fontset = FuncLoader.LoadFunction<d_pango_context_load_fontset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_context_load_fontset"));
+
+		public Pango.Fontset LoadFontset(Pango.FontDescription desc, Pango.Language language) {
+			IntPtr raw_ret = pango_context_load_fontset(Handle, desc == null ? IntPtr.Zero : desc.Handle, language == null ? IntPtr.Zero : language.Handle);
+			Pango.Fontset ret = GLib.Object.GetObject(raw_ret) as Pango.Fontset;
+			return ret;
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (GLib.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CoreTextFace.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CoreTextFace : Pango.FontFace {
+
+		public CoreTextFace(IntPtr raw) : base(raw) {}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CoreTextFaceClass.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CoreTextFaceClass : GLib.Opaque {
+
+		public CoreTextFaceClass(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CoreTextFamily.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CoreTextFamily : Pango.FontFamily {
+
+		public CoreTextFamily(IntPtr raw) : base(raw) {}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CoreTextFamilyClass.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CoreTextFamilyClass : GLib.Opaque {
+
+		public CoreTextFamilyClass(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CoreTextFont.cs

@@ -0,0 +1,36 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class CoreTextFont : Pango.Font {
+
+		public CoreTextFont (IntPtr raw) : base(raw) {}
+
+		protected CoreTextFont() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_core_text_font_get_type();
+		static d_pango_core_text_font_get_type pango_core_text_font_get_type = FuncLoader.LoadFunction<d_pango_core_text_font_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_core_text_font_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_core_text_font_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CoreTextFontKey.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CoreTextFontKey : GLib.Opaque {
+
+		public CoreTextFontKey(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CoreTextFontMap.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CoreTextFontMap : GLib.Opaque {
+
+		public CoreTextFontMap(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CoreTextFontMapClass.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CoreTextFontMapClass : GLib.Opaque {
+
+		public CoreTextFontMapClass(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CoreTextFontset.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CoreTextFontset : GLib.Opaque {
+
+		public CoreTextFontset(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CoreTextFontsetClass.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CoreTextFontsetClass : GLib.Opaque {
+
+		public CoreTextFontsetClass(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CoreTextFontsetKey.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CoreTextFontsetKey : GLib.Opaque {
+
+		public CoreTextFontsetKey(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/Coverage.cs

@@ -0,0 +1,144 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Coverage : GLib.Opaque {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_coverage_copy(IntPtr raw);
+		static d_pango_coverage_copy pango_coverage_copy = FuncLoader.LoadFunction<d_pango_coverage_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_coverage_copy"));
+
+		public Pango.Coverage Copy() {
+			IntPtr raw_ret = pango_coverage_copy(Handle);
+			Pango.Coverage ret = raw_ret == IntPtr.Zero ? null : (Pango.Coverage) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.Coverage), true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_coverage_from_bytes(out byte bytes, int n_bytes);
+		static d_pango_coverage_from_bytes pango_coverage_from_bytes = FuncLoader.LoadFunction<d_pango_coverage_from_bytes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_coverage_from_bytes"));
+
+		public static Pango.Coverage FromBytes(out byte bytes, int n_bytes) {
+			IntPtr raw_ret = pango_coverage_from_bytes(out bytes, n_bytes);
+			Pango.Coverage ret = raw_ret == IntPtr.Zero ? null : (Pango.Coverage) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.Coverage), false);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_coverage_get(IntPtr raw, int index_);
+		static d_pango_coverage_get pango_coverage_get = FuncLoader.LoadFunction<d_pango_coverage_get>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_coverage_get"));
+
+		public Pango.CoverageLevel Get(int index_) {
+			int raw_ret = pango_coverage_get(Handle, index_);
+			Pango.CoverageLevel ret = (Pango.CoverageLevel) raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_coverage_max(IntPtr raw, IntPtr other);
+		static d_pango_coverage_max pango_coverage_max = FuncLoader.LoadFunction<d_pango_coverage_max>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_coverage_max"));
+
+		public void Max(Pango.Coverage other) {
+			pango_coverage_max(Handle, other == null ? IntPtr.Zero : other.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_coverage_set(IntPtr raw, int index_, int level);
+		static d_pango_coverage_set pango_coverage_set = FuncLoader.LoadFunction<d_pango_coverage_set>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_coverage_set"));
+
+		public void Set(int index_, Pango.CoverageLevel level) {
+			pango_coverage_set(Handle, index_, (int) level);
+		}
+
+		public Coverage(IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_coverage_new();
+		static d_pango_coverage_new pango_coverage_new = FuncLoader.LoadFunction<d_pango_coverage_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_coverage_new"));
+
+		public Coverage () 
+		{
+			Raw = pango_coverage_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_coverage_ref(IntPtr raw);
+		static d_pango_coverage_ref pango_coverage_ref = FuncLoader.LoadFunction<d_pango_coverage_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_coverage_ref"));
+
+		protected override void Ref (IntPtr raw)
+		{
+			if (!Owned) {
+				pango_coverage_ref (raw);
+				Owned = true;
+			}
+		}
+
+		[Obsolete("Pango.Coverage is now refcounted automatically")]
+		public Coverage Ref () { return this; }
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_coverage_unref(IntPtr raw);
+		static d_pango_coverage_unref pango_coverage_unref = FuncLoader.LoadFunction<d_pango_coverage_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_coverage_unref"));
+
+		protected override void Unref (IntPtr raw)
+		{
+			if (Owned) {
+				pango_coverage_unref (raw);
+				Owned = false;
+			}
+		}
+
+		[Obsolete("Pango.Coverage is now refcounted automatically")]
+		public void Unref () {}
+
+		class FinalizerInfo {
+			IntPtr handle;
+			public uint timeoutHandlerId;
+
+			public FinalizerInfo (IntPtr handle)
+			{
+				this.handle = handle;
+			}
+
+			public bool Handler ()
+			{
+				pango_coverage_unref (handle);
+				GLib.Timeout.Remove(timeoutHandlerId);
+				return false;
+			}
+		}
+
+		~Coverage ()
+		{
+			if (!Owned)
+				return;
+			FinalizerInfo info = new FinalizerInfo (Handle);
+			info.timeoutHandlerId = GLib.Timeout.Add (50, new GLib.TimeoutHandler (info.Handler));
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/CoverageLevel.cs

@@ -0,0 +1,31 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Pango.CoverageLevelGType))]
+	public enum CoverageLevel {
+
+		None,
+		Fallback,
+		Approximate,
+		Exact,
+	}
+
+	internal class CoverageLevelGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_coverage_level_get_type();
+		static d_pango_coverage_level_get_type pango_coverage_level_get_type = FuncLoader.LoadFunction<d_pango_coverage_level_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_coverage_level_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (pango_coverage_level_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/Direction.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Pango.DirectionGType))]
+	public enum Direction {
+
+		Ltr,
+		Rtl,
+		TtbLtr,
+		TtbRtl,
+		WeakLtr,
+		WeakRtl,
+		Neutral,
+	}
+
+	internal class DirectionGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_direction_get_type();
+		static d_pango_direction_get_type pango_direction_get_type = FuncLoader.LoadFunction<d_pango_direction_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_direction_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (pango_direction_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/EllipsizeMode.cs

@@ -0,0 +1,31 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Pango.EllipsizeModeGType))]
+	public enum EllipsizeMode {
+
+		None,
+		Start,
+		Middle,
+		End,
+	}
+
+	internal class EllipsizeModeGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_ellipsize_mode_get_type();
+		static d_pango_ellipsize_mode_get_type pango_ellipsize_mode_get_type = FuncLoader.LoadFunction<d_pango_ellipsize_mode_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_ellipsize_mode_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (pango_ellipsize_mode_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/EllipsizeState.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class EllipsizeState : GLib.Opaque {
+
+		public EllipsizeState(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/EngineLang.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class EngineLang : GLib.Opaque {
+
+		public EngineLang(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/EngineShape.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class EngineShape : GLib.Opaque {
+
+		public EngineShape(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/Extents.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Extents : GLib.Opaque {
+
+		public Extents(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FT2Family.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class FT2Family : GLib.Opaque {
+
+		public FT2Family(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FT2Font.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class FT2Font : GLib.Opaque {
+
+		public FT2Font(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FT2FontClass.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class FT2FontClass : GLib.Opaque {
+
+		public FT2FontClass(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FT2GlyphInfo.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class FT2GlyphInfo : GLib.Opaque {
+
+		public FT2GlyphInfo(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FT2Renderer.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class FT2Renderer : GLib.Opaque {
+
+		public FT2Renderer(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FT2RendererClass.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class FT2RendererClass : GLib.Opaque {
+
+		public FT2RendererClass(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/Font.cs

@@ -0,0 +1,110 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Font : GLib.Object {
+
+		public Font (IntPtr raw) : base(raw) {}
+
+		protected Font() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_describe(IntPtr raw);
+		static d_pango_font_describe pango_font_describe = FuncLoader.LoadFunction<d_pango_font_describe>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_describe"));
+
+		public Pango.FontDescription Describe() {
+			IntPtr raw_ret = pango_font_describe(Handle);
+			Pango.FontDescription ret = raw_ret == IntPtr.Zero ? null : (Pango.FontDescription) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.FontDescription), true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_describe_with_absolute_size(IntPtr raw);
+		static d_pango_font_describe_with_absolute_size pango_font_describe_with_absolute_size = FuncLoader.LoadFunction<d_pango_font_describe_with_absolute_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_describe_with_absolute_size"));
+
+		public Pango.FontDescription DescribeWithAbsoluteSize() {
+			IntPtr raw_ret = pango_font_describe_with_absolute_size(Handle);
+			Pango.FontDescription ret = raw_ret == IntPtr.Zero ? null : (Pango.FontDescription) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.FontDescription), false);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_find_shaper(IntPtr raw, IntPtr language, uint ch);
+		static d_pango_font_find_shaper pango_font_find_shaper = FuncLoader.LoadFunction<d_pango_font_find_shaper>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_find_shaper"));
+
+		public Pango.EngineShape FindShaper(Pango.Language language, uint ch) {
+			IntPtr raw_ret = pango_font_find_shaper(Handle, language == null ? IntPtr.Zero : language.Handle, ch);
+			Pango.EngineShape ret = raw_ret == IntPtr.Zero ? null : (Pango.EngineShape) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.EngineShape), false);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_get_coverage(IntPtr raw, IntPtr language);
+		static d_pango_font_get_coverage pango_font_get_coverage = FuncLoader.LoadFunction<d_pango_font_get_coverage>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_get_coverage"));
+
+		public Pango.Coverage GetCoverage(Pango.Language language) {
+			IntPtr raw_ret = pango_font_get_coverage(Handle, language == null ? IntPtr.Zero : language.Handle);
+			Pango.Coverage ret = raw_ret == IntPtr.Zero ? null : (Pango.Coverage) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.Coverage), false);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_get_font_map(IntPtr raw);
+		static d_pango_font_get_font_map pango_font_get_font_map = FuncLoader.LoadFunction<d_pango_font_get_font_map>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_get_font_map"));
+
+		public Pango.FontMap FontMap { 
+			get {
+				IntPtr raw_ret = pango_font_get_font_map(Handle);
+				Pango.FontMap ret = GLib.Object.GetObject(raw_ret) as Pango.FontMap;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_get_glyph_extents(IntPtr raw, uint glyph, IntPtr ink_rect, IntPtr logical_rect);
+		static d_pango_font_get_glyph_extents pango_font_get_glyph_extents = FuncLoader.LoadFunction<d_pango_font_get_glyph_extents>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_get_glyph_extents"));
+
+		public void GetGlyphExtents(uint glyph, Pango.Rectangle ink_rect, Pango.Rectangle logical_rect) {
+			IntPtr native_ink_rect = GLib.Marshaller.StructureToPtrAlloc (ink_rect);
+			IntPtr native_logical_rect = GLib.Marshaller.StructureToPtrAlloc (logical_rect);
+			pango_font_get_glyph_extents(Handle, glyph, native_ink_rect, native_logical_rect);
+			Marshal.FreeHGlobal (native_ink_rect);
+			Marshal.FreeHGlobal (native_logical_rect);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_get_metrics(IntPtr raw, IntPtr language);
+		static d_pango_font_get_metrics pango_font_get_metrics = FuncLoader.LoadFunction<d_pango_font_get_metrics>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_get_metrics"));
+
+		public Pango.FontMetrics GetMetrics(Pango.Language language) {
+			IntPtr raw_ret = pango_font_get_metrics(Handle, language == null ? IntPtr.Zero : language.Handle);
+			Pango.FontMetrics ret = raw_ret == IntPtr.Zero ? null : (Pango.FontMetrics) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.FontMetrics), false);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_get_type();
+		static d_pango_font_get_type pango_font_get_type = FuncLoader.LoadFunction<d_pango_font_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_font_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FontDescription.cs

@@ -0,0 +1,381 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class FontDescription : GLib.Opaque {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_font_description_better_match(IntPtr raw, IntPtr old_match, IntPtr new_match);
+		static d_pango_font_description_better_match pango_font_description_better_match = FuncLoader.LoadFunction<d_pango_font_description_better_match>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_better_match"));
+
+		public bool BetterMatch(Pango.FontDescription old_match, Pango.FontDescription new_match) {
+			bool raw_ret = pango_font_description_better_match(Handle, old_match == null ? IntPtr.Zero : old_match.Handle, new_match == null ? IntPtr.Zero : new_match.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_description_copy(IntPtr raw);
+		static d_pango_font_description_copy pango_font_description_copy = FuncLoader.LoadFunction<d_pango_font_description_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_copy"));
+
+		public Pango.FontDescription Copy() {
+			IntPtr raw_ret = pango_font_description_copy(Handle);
+			Pango.FontDescription ret = raw_ret == IntPtr.Zero ? null : (Pango.FontDescription) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.FontDescription), true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_description_copy_static(IntPtr raw);
+		static d_pango_font_description_copy_static pango_font_description_copy_static = FuncLoader.LoadFunction<d_pango_font_description_copy_static>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_copy_static"));
+
+		public Pango.FontDescription CopyStatic() {
+			IntPtr raw_ret = pango_font_description_copy_static(Handle);
+			Pango.FontDescription ret = raw_ret == IntPtr.Zero ? null : (Pango.FontDescription) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.FontDescription), true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_font_description_equal(IntPtr raw, IntPtr desc2);
+		static d_pango_font_description_equal pango_font_description_equal = FuncLoader.LoadFunction<d_pango_font_description_equal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_equal"));
+
+		public bool Equal(Pango.FontDescription desc2) {
+			bool raw_ret = pango_font_description_equal(Handle, desc2 == null ? IntPtr.Zero : desc2.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_description_from_string(IntPtr str);
+		static d_pango_font_description_from_string pango_font_description_from_string = FuncLoader.LoadFunction<d_pango_font_description_from_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_from_string"));
+
+		public static Pango.FontDescription FromString(string str) {
+			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
+			IntPtr raw_ret = pango_font_description_from_string(native_str);
+			Pango.FontDescription ret = raw_ret == IntPtr.Zero ? null : (Pango.FontDescription) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.FontDescription), true);
+			GLib.Marshaller.Free (native_str);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_description_get_family(IntPtr raw);
+		static d_pango_font_description_get_family pango_font_description_get_family = FuncLoader.LoadFunction<d_pango_font_description_get_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_get_family"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_set_family(IntPtr raw, IntPtr family);
+		static d_pango_font_description_set_family pango_font_description_set_family = FuncLoader.LoadFunction<d_pango_font_description_set_family>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_set_family"));
+
+		public string Family { 
+			get {
+				IntPtr raw_ret = pango_font_description_get_family(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+			set {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				pango_font_description_set_family(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_description_get_gravity(IntPtr raw);
+		static d_pango_font_description_get_gravity pango_font_description_get_gravity = FuncLoader.LoadFunction<d_pango_font_description_get_gravity>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_get_gravity"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_set_gravity(IntPtr raw, int gravity);
+		static d_pango_font_description_set_gravity pango_font_description_set_gravity = FuncLoader.LoadFunction<d_pango_font_description_set_gravity>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_set_gravity"));
+
+		public Pango.Gravity Gravity { 
+			get {
+				int raw_ret = pango_font_description_get_gravity(Handle);
+				Pango.Gravity ret = (Pango.Gravity) raw_ret;
+				return ret;
+			}
+			set {
+				pango_font_description_set_gravity(Handle, (int) value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_description_get_set_fields(IntPtr raw);
+		static d_pango_font_description_get_set_fields pango_font_description_get_set_fields = FuncLoader.LoadFunction<d_pango_font_description_get_set_fields>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_get_set_fields"));
+
+		public Pango.FontMask SetFields { 
+			get {
+				int raw_ret = pango_font_description_get_set_fields(Handle);
+				Pango.FontMask ret = (Pango.FontMask) raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_description_get_size(IntPtr raw);
+		static d_pango_font_description_get_size pango_font_description_get_size = FuncLoader.LoadFunction<d_pango_font_description_get_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_get_size"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_set_size(IntPtr raw, int size);
+		static d_pango_font_description_set_size pango_font_description_set_size = FuncLoader.LoadFunction<d_pango_font_description_set_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_set_size"));
+
+		public int Size { 
+			get {
+				int raw_ret = pango_font_description_get_size(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+			set {
+				pango_font_description_set_size(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_font_description_get_size_is_absolute(IntPtr raw);
+		static d_pango_font_description_get_size_is_absolute pango_font_description_get_size_is_absolute = FuncLoader.LoadFunction<d_pango_font_description_get_size_is_absolute>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_get_size_is_absolute"));
+
+		public bool SizeIsAbsolute { 
+			get {
+				bool raw_ret = pango_font_description_get_size_is_absolute(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_description_get_stretch(IntPtr raw);
+		static d_pango_font_description_get_stretch pango_font_description_get_stretch = FuncLoader.LoadFunction<d_pango_font_description_get_stretch>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_get_stretch"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_set_stretch(IntPtr raw, int stretch);
+		static d_pango_font_description_set_stretch pango_font_description_set_stretch = FuncLoader.LoadFunction<d_pango_font_description_set_stretch>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_set_stretch"));
+
+		public Pango.Stretch Stretch { 
+			get {
+				int raw_ret = pango_font_description_get_stretch(Handle);
+				Pango.Stretch ret = (Pango.Stretch) raw_ret;
+				return ret;
+			}
+			set {
+				pango_font_description_set_stretch(Handle, (int) value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_description_get_style(IntPtr raw);
+		static d_pango_font_description_get_style pango_font_description_get_style = FuncLoader.LoadFunction<d_pango_font_description_get_style>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_get_style"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_set_style(IntPtr raw, int style);
+		static d_pango_font_description_set_style pango_font_description_set_style = FuncLoader.LoadFunction<d_pango_font_description_set_style>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_set_style"));
+
+		public Pango.Style Style { 
+			get {
+				int raw_ret = pango_font_description_get_style(Handle);
+				Pango.Style ret = (Pango.Style) raw_ret;
+				return ret;
+			}
+			set {
+				pango_font_description_set_style(Handle, (int) value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_description_get_type();
+		static d_pango_font_description_get_type pango_font_description_get_type = FuncLoader.LoadFunction<d_pango_font_description_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_font_description_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_description_get_variant(IntPtr raw);
+		static d_pango_font_description_get_variant pango_font_description_get_variant = FuncLoader.LoadFunction<d_pango_font_description_get_variant>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_get_variant"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_set_variant(IntPtr raw, int variant);
+		static d_pango_font_description_set_variant pango_font_description_set_variant = FuncLoader.LoadFunction<d_pango_font_description_set_variant>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_set_variant"));
+
+		public Pango.Variant Variant { 
+			get {
+				int raw_ret = pango_font_description_get_variant(Handle);
+				Pango.Variant ret = (Pango.Variant) raw_ret;
+				return ret;
+			}
+			set {
+				pango_font_description_set_variant(Handle, (int) value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_description_get_weight(IntPtr raw);
+		static d_pango_font_description_get_weight pango_font_description_get_weight = FuncLoader.LoadFunction<d_pango_font_description_get_weight>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_get_weight"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_set_weight(IntPtr raw, int weight);
+		static d_pango_font_description_set_weight pango_font_description_set_weight = FuncLoader.LoadFunction<d_pango_font_description_set_weight>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_set_weight"));
+
+		public Pango.Weight Weight { 
+			get {
+				int raw_ret = pango_font_description_get_weight(Handle);
+				Pango.Weight ret = (Pango.Weight) raw_ret;
+				return ret;
+			}
+			set {
+				pango_font_description_set_weight(Handle, (int) value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_pango_font_description_hash(IntPtr raw);
+		static d_pango_font_description_hash pango_font_description_hash = FuncLoader.LoadFunction<d_pango_font_description_hash>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_hash"));
+
+		public uint Hash { 
+			get {
+				uint raw_ret = pango_font_description_hash(Handle);
+				uint ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_merge(IntPtr raw, IntPtr desc_to_merge, bool replace_existing);
+		static d_pango_font_description_merge pango_font_description_merge = FuncLoader.LoadFunction<d_pango_font_description_merge>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_merge"));
+
+		public void Merge(Pango.FontDescription desc_to_merge, bool replace_existing) {
+			pango_font_description_merge(Handle, desc_to_merge == null ? IntPtr.Zero : desc_to_merge.Handle, replace_existing);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_merge_static(IntPtr raw, IntPtr desc_to_merge, bool replace_existing);
+		static d_pango_font_description_merge_static pango_font_description_merge_static = FuncLoader.LoadFunction<d_pango_font_description_merge_static>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_merge_static"));
+
+		public void MergeStatic(Pango.FontDescription desc_to_merge, bool replace_existing) {
+			pango_font_description_merge_static(Handle, desc_to_merge == null ? IntPtr.Zero : desc_to_merge.Handle, replace_existing);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_set_absolute_size(IntPtr raw, double size);
+		static d_pango_font_description_set_absolute_size pango_font_description_set_absolute_size = FuncLoader.LoadFunction<d_pango_font_description_set_absolute_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_set_absolute_size"));
+
+		public double AbsoluteSize { 
+			set {
+				pango_font_description_set_absolute_size(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_set_family_static(IntPtr raw, IntPtr family);
+		static d_pango_font_description_set_family_static pango_font_description_set_family_static = FuncLoader.LoadFunction<d_pango_font_description_set_family_static>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_set_family_static"));
+
+		public string FamilyStatic { 
+			set {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				pango_font_description_set_family_static(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_description_to_filename(IntPtr raw);
+		static d_pango_font_description_to_filename pango_font_description_to_filename = FuncLoader.LoadFunction<d_pango_font_description_to_filename>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_to_filename"));
+
+		public string ToFilename() {
+			IntPtr raw_ret = pango_font_description_to_filename(Handle);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_description_to_string(IntPtr raw);
+		static d_pango_font_description_to_string pango_font_description_to_string = FuncLoader.LoadFunction<d_pango_font_description_to_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_to_string"));
+
+		public override string ToString() {
+			IntPtr raw_ret = pango_font_description_to_string(Handle);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_unset_fields(IntPtr raw, int to_unset);
+		static d_pango_font_description_unset_fields pango_font_description_unset_fields = FuncLoader.LoadFunction<d_pango_font_description_unset_fields>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_unset_fields"));
+
+		public void UnsetFields(Pango.FontMask to_unset) {
+			pango_font_description_unset_fields(Handle, (int) to_unset);
+		}
+
+		public FontDescription(IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_description_new();
+		static d_pango_font_description_new pango_font_description_new = FuncLoader.LoadFunction<d_pango_font_description_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_new"));
+
+		public FontDescription () 
+		{
+			Raw = pango_font_description_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_description_free(IntPtr raw);
+		static d_pango_font_description_free pango_font_description_free = FuncLoader.LoadFunction<d_pango_font_description_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_description_free"));
+
+		protected override void Free (IntPtr raw)
+		{
+			pango_font_description_free (raw);
+		}
+
+		[Obsolete("Pango.FontDescription is now freed automatically")]
+		public void Free () {}
+
+		class FinalizerInfo {
+			IntPtr handle;
+			public uint timeoutHandlerId;
+
+			public FinalizerInfo (IntPtr handle)
+			{
+				this.handle = handle;
+			}
+
+			public bool Handler ()
+			{
+				pango_font_description_free (handle);
+				GLib.Timeout.Remove(timeoutHandlerId);
+				return false;
+			}
+		}
+
+		~FontDescription ()
+		{
+			if (!Owned)
+				return;
+			FinalizerInfo info = new FinalizerInfo (Handle);
+			info.timeoutHandlerId = GLib.Timeout.Add (50, new GLib.TimeoutHandler (info.Handler));
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FontFace.cs

@@ -0,0 +1,78 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class FontFace : GLib.Object {
+
+		public FontFace (IntPtr raw) : base(raw) {}
+
+		protected FontFace() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_face_describe(IntPtr raw);
+		static d_pango_font_face_describe pango_font_face_describe = FuncLoader.LoadFunction<d_pango_font_face_describe>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_face_describe"));
+
+		public Pango.FontDescription Describe() {
+			IntPtr raw_ret = pango_font_face_describe(Handle);
+			Pango.FontDescription ret = raw_ret == IntPtr.Zero ? null : (Pango.FontDescription) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.FontDescription), true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_face_get_face_name(IntPtr raw);
+		static d_pango_font_face_get_face_name pango_font_face_get_face_name = FuncLoader.LoadFunction<d_pango_font_face_get_face_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_face_get_face_name"));
+
+		public string FaceName { 
+			get {
+				IntPtr raw_ret = pango_font_face_get_face_name(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_face_get_type();
+		static d_pango_font_face_get_type pango_font_face_get_type = FuncLoader.LoadFunction<d_pango_font_face_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_face_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_font_face_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_font_face_is_synthesized(IntPtr raw);
+		static d_pango_font_face_is_synthesized pango_font_face_is_synthesized = FuncLoader.LoadFunction<d_pango_font_face_is_synthesized>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_face_is_synthesized"));
+
+		public bool IsSynthesized { 
+			get {
+				bool raw_ret = pango_font_face_is_synthesized(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_face_list_sizes(IntPtr raw, out int sizes, out int n_sizes);
+		static d_pango_font_face_list_sizes pango_font_face_list_sizes = FuncLoader.LoadFunction<d_pango_font_face_list_sizes>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_face_list_sizes"));
+
+		public void ListSizes(out int sizes, out int n_sizes) {
+			pango_font_face_list_sizes(Handle, out sizes, out n_sizes);
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FontFamily.cs

@@ -0,0 +1,60 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class FontFamily : GLib.Object {
+
+		public FontFamily (IntPtr raw) : base(raw) {}
+
+		protected FontFamily() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_family_get_name(IntPtr raw);
+		static d_pango_font_family_get_name pango_font_family_get_name = FuncLoader.LoadFunction<d_pango_font_family_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_family_get_name"));
+
+		public string Name { 
+			get {
+				IntPtr raw_ret = pango_font_family_get_name(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_family_get_type();
+		static d_pango_font_family_get_type pango_font_family_get_type = FuncLoader.LoadFunction<d_pango_font_family_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_family_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_font_family_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_font_family_is_monospace(IntPtr raw);
+		static d_pango_font_family_is_monospace pango_font_family_is_monospace = FuncLoader.LoadFunction<d_pango_font_family_is_monospace>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_family_is_monospace"));
+
+		public bool IsMonospace { 
+			get {
+				bool raw_ret = pango_font_family_is_monospace(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FontHashKey.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class FontHashKey : GLib.Opaque {
+
+		public FontHashKey(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FontMap.cs

@@ -0,0 +1,86 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class FontMap : GLib.Object {
+
+		public FontMap (IntPtr raw) : base(raw) {}
+
+		protected FontMap() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_map_changed(IntPtr raw);
+		static d_pango_font_map_changed pango_font_map_changed = FuncLoader.LoadFunction<d_pango_font_map_changed>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_map_changed"));
+
+		public void Changed() {
+			pango_font_map_changed(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_map_create_context(IntPtr raw);
+		static d_pango_font_map_create_context pango_font_map_create_context = FuncLoader.LoadFunction<d_pango_font_map_create_context>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_map_create_context"));
+
+		public Pango.Context CreateContext() {
+			IntPtr raw_ret = pango_font_map_create_context(Handle);
+			Pango.Context ret = GLib.Object.GetObject(raw_ret) as Pango.Context;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_pango_font_map_get_serial(IntPtr raw);
+		static d_pango_font_map_get_serial pango_font_map_get_serial = FuncLoader.LoadFunction<d_pango_font_map_get_serial>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_map_get_serial"));
+
+		public uint Serial { 
+			get {
+				uint raw_ret = pango_font_map_get_serial(Handle);
+				uint ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_map_get_type();
+		static d_pango_font_map_get_type pango_font_map_get_type = FuncLoader.LoadFunction<d_pango_font_map_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_map_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_font_map_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_map_load_font(IntPtr raw, IntPtr context, IntPtr desc);
+		static d_pango_font_map_load_font pango_font_map_load_font = FuncLoader.LoadFunction<d_pango_font_map_load_font>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_map_load_font"));
+
+		public Pango.Font LoadFont(Pango.Context context, Pango.FontDescription desc) {
+			IntPtr raw_ret = pango_font_map_load_font(Handle, context == null ? IntPtr.Zero : context.Handle, desc == null ? IntPtr.Zero : desc.Handle);
+			Pango.Font ret = GLib.Object.GetObject(raw_ret) as Pango.Font;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_map_load_fontset(IntPtr raw, IntPtr context, IntPtr desc, IntPtr language);
+		static d_pango_font_map_load_fontset pango_font_map_load_fontset = FuncLoader.LoadFunction<d_pango_font_map_load_fontset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_map_load_fontset"));
+
+		public Pango.Fontset LoadFontset(Pango.Context context, Pango.FontDescription desc, Pango.Language language) {
+			IntPtr raw_ret = pango_font_map_load_fontset(Handle, context == null ? IntPtr.Zero : context.Handle, desc == null ? IntPtr.Zero : desc.Handle, language == null ? IntPtr.Zero : language.Handle);
+			Pango.Fontset ret = GLib.Object.GetObject(raw_ret) as Pango.Fontset;
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FontMask.cs

@@ -0,0 +1,35 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	[GLib.GType (typeof (Pango.FontMaskGType))]
+	public enum FontMask {
+
+		Family = 1 << 0,
+		Style = 1 << 1,
+		Variant = 1 << 2,
+		Weight = 1 << 3,
+		Stretch = 1 << 4,
+		Size = 1 << 5,
+		Gravity = 1 << 6,
+	}
+
+	internal class FontMaskGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_mask_get_type();
+		static d_pango_font_mask_get_type pango_font_mask_get_type = FuncLoader.LoadFunction<d_pango_font_mask_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_mask_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (pango_font_mask_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FontMetrics.cs

@@ -0,0 +1,197 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class FontMetrics : GLib.Opaque {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_metrics_get_approximate_char_width(IntPtr raw);
+		static d_pango_font_metrics_get_approximate_char_width pango_font_metrics_get_approximate_char_width = FuncLoader.LoadFunction<d_pango_font_metrics_get_approximate_char_width>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_metrics_get_approximate_char_width"));
+
+		public int ApproximateCharWidth { 
+			get {
+				int raw_ret = pango_font_metrics_get_approximate_char_width(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_metrics_get_approximate_digit_width(IntPtr raw);
+		static d_pango_font_metrics_get_approximate_digit_width pango_font_metrics_get_approximate_digit_width = FuncLoader.LoadFunction<d_pango_font_metrics_get_approximate_digit_width>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_metrics_get_approximate_digit_width"));
+
+		public int ApproximateDigitWidth { 
+			get {
+				int raw_ret = pango_font_metrics_get_approximate_digit_width(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_metrics_get_ascent(IntPtr raw);
+		static d_pango_font_metrics_get_ascent pango_font_metrics_get_ascent = FuncLoader.LoadFunction<d_pango_font_metrics_get_ascent>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_metrics_get_ascent"));
+
+		public int Ascent { 
+			get {
+				int raw_ret = pango_font_metrics_get_ascent(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_metrics_get_descent(IntPtr raw);
+		static d_pango_font_metrics_get_descent pango_font_metrics_get_descent = FuncLoader.LoadFunction<d_pango_font_metrics_get_descent>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_metrics_get_descent"));
+
+		public int Descent { 
+			get {
+				int raw_ret = pango_font_metrics_get_descent(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_metrics_get_strikethrough_position(IntPtr raw);
+		static d_pango_font_metrics_get_strikethrough_position pango_font_metrics_get_strikethrough_position = FuncLoader.LoadFunction<d_pango_font_metrics_get_strikethrough_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_metrics_get_strikethrough_position"));
+
+		public int StrikethroughPosition { 
+			get {
+				int raw_ret = pango_font_metrics_get_strikethrough_position(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_metrics_get_strikethrough_thickness(IntPtr raw);
+		static d_pango_font_metrics_get_strikethrough_thickness pango_font_metrics_get_strikethrough_thickness = FuncLoader.LoadFunction<d_pango_font_metrics_get_strikethrough_thickness>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_metrics_get_strikethrough_thickness"));
+
+		public int StrikethroughThickness { 
+			get {
+				int raw_ret = pango_font_metrics_get_strikethrough_thickness(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_metrics_get_type();
+		static d_pango_font_metrics_get_type pango_font_metrics_get_type = FuncLoader.LoadFunction<d_pango_font_metrics_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_metrics_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_font_metrics_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_metrics_get_underline_position(IntPtr raw);
+		static d_pango_font_metrics_get_underline_position pango_font_metrics_get_underline_position = FuncLoader.LoadFunction<d_pango_font_metrics_get_underline_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_metrics_get_underline_position"));
+
+		public int UnderlinePosition { 
+			get {
+				int raw_ret = pango_font_metrics_get_underline_position(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_font_metrics_get_underline_thickness(IntPtr raw);
+		static d_pango_font_metrics_get_underline_thickness pango_font_metrics_get_underline_thickness = FuncLoader.LoadFunction<d_pango_font_metrics_get_underline_thickness>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_metrics_get_underline_thickness"));
+
+		public int UnderlineThickness { 
+			get {
+				int raw_ret = pango_font_metrics_get_underline_thickness(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		public FontMetrics(IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_font_metrics_ref(IntPtr raw);
+		static d_pango_font_metrics_ref pango_font_metrics_ref = FuncLoader.LoadFunction<d_pango_font_metrics_ref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_metrics_ref"));
+
+		protected override void Ref (IntPtr raw)
+		{
+			if (!Owned) {
+				pango_font_metrics_ref (raw);
+				Owned = true;
+			}
+		}
+
+		[Obsolete("Pango.FontMetrics is now refcounted automatically")]
+		public FontMetrics Ref () { return this; }
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_font_metrics_unref(IntPtr raw);
+		static d_pango_font_metrics_unref pango_font_metrics_unref = FuncLoader.LoadFunction<d_pango_font_metrics_unref>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_font_metrics_unref"));
+
+		protected override void Unref (IntPtr raw)
+		{
+			if (Owned) {
+				pango_font_metrics_unref (raw);
+				Owned = false;
+			}
+		}
+
+		[Obsolete("Pango.FontMetrics is now refcounted automatically")]
+		public void Unref () {}
+
+		class FinalizerInfo {
+			IntPtr handle;
+			public uint timeoutHandlerId;
+
+			public FinalizerInfo (IntPtr handle)
+			{
+				this.handle = handle;
+			}
+
+			public bool Handler ()
+			{
+				pango_font_metrics_unref (handle);
+				GLib.Timeout.Remove(timeoutHandlerId);
+				return false;
+			}
+		}
+
+		~FontMetrics ()
+		{
+			if (!Owned)
+				return;
+			FinalizerInfo info = new FinalizerInfo (Handle);
+			info.timeoutHandlerId = GLib.Timeout.Add (50, new GLib.TimeoutHandler (info.Handler));
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/Fontset.cs

@@ -0,0 +1,67 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Fontset : GLib.Object {
+
+		public Fontset (IntPtr raw) : base(raw) {}
+
+		protected Fontset() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_fontset_foreach(IntPtr raw, PangoSharp.FontsetForeachFuncNative func, IntPtr data);
+		static d_pango_fontset_foreach pango_fontset_foreach = FuncLoader.LoadFunction<d_pango_fontset_foreach>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_fontset_foreach"));
+
+		public void Foreach(Pango.FontsetForeachFunc func) {
+			PangoSharp.FontsetForeachFuncWrapper func_wrapper = new PangoSharp.FontsetForeachFuncWrapper (func);
+			pango_fontset_foreach(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_fontset_get_font(IntPtr raw, uint wc);
+		static d_pango_fontset_get_font pango_fontset_get_font = FuncLoader.LoadFunction<d_pango_fontset_get_font>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_fontset_get_font"));
+
+		public Pango.Font GetFont(uint wc) {
+			IntPtr raw_ret = pango_fontset_get_font(Handle, wc);
+			Pango.Font ret = GLib.Object.GetObject(raw_ret) as Pango.Font;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_fontset_get_metrics(IntPtr raw);
+		static d_pango_fontset_get_metrics pango_fontset_get_metrics = FuncLoader.LoadFunction<d_pango_fontset_get_metrics>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_fontset_get_metrics"));
+
+		public Pango.FontMetrics Metrics { 
+			get {
+				IntPtr raw_ret = pango_fontset_get_metrics(Handle);
+				Pango.FontMetrics ret = raw_ret == IntPtr.Zero ? null : (Pango.FontMetrics) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.FontMetrics), false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_fontset_get_type();
+		static d_pango_fontset_get_type pango_fontset_get_type = FuncLoader.LoadFunction<d_pango_fontset_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_fontset_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_fontset_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/FontsetForeachFunc.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+
+	public delegate bool FontsetForeachFunc(Pango.Fontset fontset, Pango.Font font);
+
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/Global.cs

@@ -0,0 +1,331 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Global {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_bidi_type_for_unichar(uint ch);
+		static d_pango_bidi_type_for_unichar pango_bidi_type_for_unichar = FuncLoader.LoadFunction<d_pango_bidi_type_for_unichar>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_bidi_type_for_unichar"));
+
+		public static Pango.BidiType BidiTypeForUnichar(char ch) {
+			int raw_ret = pango_bidi_type_for_unichar(GLib.Marshaller.CharToGUnichar (ch));
+			Pango.BidiType ret = (Pango.BidiType) raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_extents_to_pixels(IntPtr inclusive, IntPtr nearest);
+		static d_pango_extents_to_pixels pango_extents_to_pixels = FuncLoader.LoadFunction<d_pango_extents_to_pixels>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_extents_to_pixels"));
+
+		public static void ExtentsToPixels(ref Pango.Rectangle inclusive, ref Pango.Rectangle nearest) {
+			IntPtr native_inclusive = GLib.Marshaller.StructureToPtrAlloc (inclusive);
+			IntPtr native_nearest = GLib.Marshaller.StructureToPtrAlloc (nearest);
+			pango_extents_to_pixels(native_inclusive, native_nearest);
+			inclusive = Pango.Rectangle.New (native_inclusive);
+			Marshal.FreeHGlobal (native_inclusive);
+			nearest = Pango.Rectangle.New (native_nearest);
+			Marshal.FreeHGlobal (native_nearest);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_find_base_dir(IntPtr text, int length);
+		static d_pango_find_base_dir pango_find_base_dir = FuncLoader.LoadFunction<d_pango_find_base_dir>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_find_base_dir"));
+
+		public static Pango.Direction FindBaseDir(string text) {
+			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
+			int raw_ret = pango_find_base_dir(native_text, System.Text.Encoding.UTF8.GetByteCount (text));
+			Pango.Direction ret = (Pango.Direction) raw_ret;
+			GLib.Marshaller.Free (native_text);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_find_paragraph_boundary(IntPtr text, int length, out int paragraph_delimiter_index, out int next_paragraph_start);
+		static d_pango_find_paragraph_boundary pango_find_paragraph_boundary = FuncLoader.LoadFunction<d_pango_find_paragraph_boundary>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_find_paragraph_boundary"));
+
+		public static void FindParagraphBoundary(string text, out int paragraph_delimiter_index, out int next_paragraph_start) {
+			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
+			pango_find_paragraph_boundary(native_text, System.Text.Encoding.UTF8.GetByteCount (text), out paragraph_delimiter_index, out next_paragraph_start);
+			GLib.Marshaller.Free (native_text);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_get_log_attrs(IntPtr text, int length, int level, IntPtr language, IntPtr log_attrs, int attrs_len);
+		static d_pango_get_log_attrs pango_get_log_attrs = FuncLoader.LoadFunction<d_pango_get_log_attrs>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_get_log_attrs"));
+
+		public static void GetLogAttrs(string text, int level, Pango.Language language, Pango.LogAttr log_attrs, int attrs_len) {
+			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
+			IntPtr native_log_attrs = GLib.Marshaller.StructureToPtrAlloc (log_attrs);
+			pango_get_log_attrs(native_text, System.Text.Encoding.UTF8.GetByteCount (text), level, language == null ? IntPtr.Zero : language.Handle, native_log_attrs, attrs_len);
+			GLib.Marshaller.Free (native_text);
+			Marshal.FreeHGlobal (native_log_attrs);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_gravity_get_for_matrix(IntPtr matrix);
+		static d_pango_gravity_get_for_matrix pango_gravity_get_for_matrix = FuncLoader.LoadFunction<d_pango_gravity_get_for_matrix>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_gravity_get_for_matrix"));
+
+		public static Pango.Gravity GravityGetForMatrix(Pango.Matrix matrix) {
+			IntPtr native_matrix = GLib.Marshaller.StructureToPtrAlloc (matrix);
+			int raw_ret = pango_gravity_get_for_matrix(native_matrix);
+			Pango.Gravity ret = (Pango.Gravity) raw_ret;
+			Marshal.FreeHGlobal (native_matrix);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_gravity_get_for_script(int script, int base_gravity, int hint);
+		static d_pango_gravity_get_for_script pango_gravity_get_for_script = FuncLoader.LoadFunction<d_pango_gravity_get_for_script>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_gravity_get_for_script"));
+
+		public static Pango.Gravity GravityGetForScript(Pango.Script script, Pango.Gravity base_gravity, Pango.GravityHint hint) {
+			int raw_ret = pango_gravity_get_for_script((int) script, (int) base_gravity, (int) hint);
+			Pango.Gravity ret = (Pango.Gravity) raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_gravity_get_for_script_and_width(int script, bool wide, int base_gravity, int hint);
+		static d_pango_gravity_get_for_script_and_width pango_gravity_get_for_script_and_width = FuncLoader.LoadFunction<d_pango_gravity_get_for_script_and_width>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_gravity_get_for_script_and_width"));
+
+		public static Pango.Gravity GravityGetForScriptAndWidth(Pango.Script script, bool wide, Pango.Gravity base_gravity, Pango.GravityHint hint) {
+			int raw_ret = pango_gravity_get_for_script_and_width((int) script, wide, (int) base_gravity, (int) hint);
+			Pango.Gravity ret = (Pango.Gravity) raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_pango_gravity_to_rotation(int gravity);
+		static d_pango_gravity_to_rotation pango_gravity_to_rotation = FuncLoader.LoadFunction<d_pango_gravity_to_rotation>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_gravity_to_rotation"));
+
+		public static double GravityToRotation(Pango.Gravity gravity) {
+			double raw_ret = pango_gravity_to_rotation((int) gravity);
+			double ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_is_zero_width(uint ch);
+		static d_pango_is_zero_width pango_is_zero_width = FuncLoader.LoadFunction<d_pango_is_zero_width>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_is_zero_width"));
+
+		public static bool IsZeroWidth(char ch) {
+			bool raw_ret = pango_is_zero_width(GLib.Marshaller.CharToGUnichar (ch));
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_itemize_with_base_dir(IntPtr context, int base_dir, IntPtr text, int start_index, int length, IntPtr attrs, IntPtr cached_iter);
+		static d_pango_itemize_with_base_dir pango_itemize_with_base_dir = FuncLoader.LoadFunction<d_pango_itemize_with_base_dir>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_itemize_with_base_dir"));
+
+		public static Pango.Item[] ItemizeWithBaseDir(Pango.Context context, Pango.Direction base_dir, string text, int start_index, int length, Pango.AttrList attrs, Pango.AttrIterator cached_iter) {
+			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
+			IntPtr raw_ret = pango_itemize_with_base_dir(context == null ? IntPtr.Zero : context.Handle, (int) base_dir, native_text, start_index, length, attrs == null ? IntPtr.Zero : attrs.Handle, cached_iter == null ? IntPtr.Zero : cached_iter.Handle);
+			Pango.Item[] ret = GLib.Marshaller.ListPtrToArray<Pango.Item, Pango.Item> (raw_ret, true, true);
+			GLib.Marshaller.Free (native_text);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_parse_enum(IntPtr type, IntPtr str, out int value, bool warn, IntPtr possible_values);
+		static d_pango_parse_enum pango_parse_enum = FuncLoader.LoadFunction<d_pango_parse_enum>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_parse_enum"));
+
+		[Obsolete]
+		public static bool ParseEnum(GLib.GType type, string str, out int value, bool warn, string possible_values) {
+			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
+			bool raw_ret = pango_parse_enum(type.Val, native_str, out value, warn, GLib.Marshaller.StringToPtrGStrdup(possible_values));
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_str);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_parse_stretch(IntPtr str, out int stretch, bool warn);
+		static d_pango_parse_stretch pango_parse_stretch = FuncLoader.LoadFunction<d_pango_parse_stretch>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_parse_stretch"));
+
+		public static bool ParseStretch(string str, out Pango.Stretch stretch, bool warn) {
+			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
+			int native_stretch;
+			bool raw_ret = pango_parse_stretch(native_str, out native_stretch, warn);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_str);
+			stretch = (Pango.Stretch) native_stretch;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_parse_style(IntPtr str, out int style, bool warn);
+		static d_pango_parse_style pango_parse_style = FuncLoader.LoadFunction<d_pango_parse_style>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_parse_style"));
+
+		public static bool ParseStyle(string str, out Pango.Style style, bool warn) {
+			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
+			int native_style;
+			bool raw_ret = pango_parse_style(native_str, out native_style, warn);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_str);
+			style = (Pango.Style) native_style;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_parse_variant(IntPtr str, out int variant, bool warn);
+		static d_pango_parse_variant pango_parse_variant = FuncLoader.LoadFunction<d_pango_parse_variant>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_parse_variant"));
+
+		public static bool ParseVariant(string str, out Pango.Variant variant, bool warn) {
+			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
+			int native_variant;
+			bool raw_ret = pango_parse_variant(native_str, out native_variant, warn);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_str);
+			variant = (Pango.Variant) native_variant;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_parse_weight(IntPtr str, out int weight, bool warn);
+		static d_pango_parse_weight pango_parse_weight = FuncLoader.LoadFunction<d_pango_parse_weight>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_parse_weight"));
+
+		public static bool ParseWeight(string str, out Pango.Weight weight, bool warn) {
+			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
+			int native_weight;
+			bool raw_ret = pango_parse_weight(native_str, out native_weight, warn);
+			bool ret = raw_ret;
+			GLib.Marshaller.Free (native_str);
+			weight = (Pango.Weight) native_weight;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_quantize_line_geometry(out int thickness, out int position);
+		static d_pango_quantize_line_geometry pango_quantize_line_geometry = FuncLoader.LoadFunction<d_pango_quantize_line_geometry>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_quantize_line_geometry"));
+
+		public static void QuantizeLineGeometry(out int thickness, out int position) {
+			pango_quantize_line_geometry(out thickness, out position);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_scan_int(ref IntPtr pos, out int out_param);
+		static d_pango_scan_int pango_scan_int = FuncLoader.LoadFunction<d_pango_scan_int>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_scan_int"));
+
+		[Obsolete]
+		public static bool ScanInt(ref string pos, out int out_param) {
+			IntPtr native_pos = GLib.Marshaller.StringToPtrGStrdup (pos);
+			bool raw_ret = pango_scan_int(ref native_pos, out out_param);
+			bool ret = raw_ret;
+			pos = GLib.Marshaller.Utf8PtrToString (native_pos);
+			GLib.Marshaller.Free (native_pos);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_script_for_unichar(uint ch);
+		static d_pango_script_for_unichar pango_script_for_unichar = FuncLoader.LoadFunction<d_pango_script_for_unichar>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_script_for_unichar"));
+
+		public static Pango.Script ScriptForUnichar(char ch) {
+			int raw_ret = pango_script_for_unichar(GLib.Marshaller.CharToGUnichar (ch));
+			Pango.Script ret = (Pango.Script) raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_script_get_sample_language(int script);
+		static d_pango_script_get_sample_language pango_script_get_sample_language = FuncLoader.LoadFunction<d_pango_script_get_sample_language>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_script_get_sample_language"));
+
+		public static Pango.Language ScriptGetSampleLanguage(Pango.Script script) {
+			IntPtr raw_ret = pango_script_get_sample_language((int) script);
+			Pango.Language ret = raw_ret == IntPtr.Zero ? null : (Pango.Language) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.Language), false);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_shape_full(IntPtr item_text, int item_length, IntPtr paragraph_text, int paragraph_length, IntPtr analysis, IntPtr glyphs);
+		static d_pango_shape_full pango_shape_full = FuncLoader.LoadFunction<d_pango_shape_full>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_shape_full"));
+
+		public static void ShapeFull(string item_text, string paragraph_text, Pango.Analysis analysis, Pango.GlyphString glyphs) {
+			IntPtr native_item_text = GLib.Marshaller.StringToPtrGStrdup (item_text);
+			IntPtr native_paragraph_text = GLib.Marshaller.StringToPtrGStrdup (paragraph_text);
+			IntPtr native_analysis = GLib.Marshaller.StructureToPtrAlloc (analysis);
+			pango_shape_full(native_item_text, System.Text.Encoding.UTF8.GetByteCount (item_text), native_paragraph_text, System.Text.Encoding.UTF8.GetByteCount (paragraph_text), native_analysis, glyphs == null ? IntPtr.Zero : glyphs.Handle);
+			GLib.Marshaller.Free (native_item_text);
+			GLib.Marshaller.Free (native_paragraph_text);
+			Marshal.FreeHGlobal (native_analysis);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_skip_space(ref IntPtr pos);
+		static d_pango_skip_space pango_skip_space = FuncLoader.LoadFunction<d_pango_skip_space>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_skip_space"));
+
+		[Obsolete]
+		public static bool SkipSpace(ref string pos) {
+			IntPtr native_pos = GLib.Marshaller.StringToPtrGStrdup (pos);
+			bool raw_ret = pango_skip_space(ref native_pos);
+			bool ret = raw_ret;
+			pos = GLib.Marshaller.Utf8PtrToString (native_pos);
+			GLib.Marshaller.Free (native_pos);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_split_file_list(IntPtr str);
+		static d_pango_split_file_list pango_split_file_list = FuncLoader.LoadFunction<d_pango_split_file_list>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_split_file_list"));
+
+		[Obsolete]
+		public static string SplitFileList(string str) {
+			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
+			IntPtr raw_ret = pango_split_file_list(native_str);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			GLib.Marshaller.Free (native_str);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_trim_string(IntPtr str);
+		static d_pango_trim_string pango_trim_string = FuncLoader.LoadFunction<d_pango_trim_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_trim_string"));
+
+		[Obsolete]
+		public static string TrimString(string str) {
+			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
+			IntPtr raw_ret = pango_trim_string(native_str);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			GLib.Marshaller.Free (native_str);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_unichar_direction(uint ch);
+		static d_pango_unichar_direction pango_unichar_direction = FuncLoader.LoadFunction<d_pango_unichar_direction>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_unichar_direction"));
+
+		public static Pango.Direction UnicharDirection(char ch) {
+			int raw_ret = pango_unichar_direction(GLib.Marshaller.CharToGUnichar (ch));
+			Pango.Direction ret = (Pango.Direction) raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_version_check(int required_major, int required_minor, int required_micro);
+		static d_pango_version_check pango_version_check = FuncLoader.LoadFunction<d_pango_version_check>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_version_check"));
+
+		public static string VersionCheck(int required_major, int required_minor, int required_micro) {
+			IntPtr raw_ret = pango_version_check(required_major, required_minor, required_micro);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_version_string();
+		static d_pango_version_string pango_version_string = FuncLoader.LoadFunction<d_pango_version_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_version_string"));
+
+		public static string VersionString() {
+			IntPtr raw_ret = pango_version_string();
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/GlyphGeometry.cs

@@ -0,0 +1,47 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct GlyphGeometry : IEquatable<GlyphGeometry> {
+
+		public int Width;
+		public int XOffset;
+		public int YOffset;
+
+		public static Pango.GlyphGeometry Zero = new Pango.GlyphGeometry ();
+
+		public static Pango.GlyphGeometry New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Pango.GlyphGeometry.Zero;
+			return (Pango.GlyphGeometry) Marshal.PtrToStructure (raw, typeof (Pango.GlyphGeometry));
+		}
+
+		public bool Equals (GlyphGeometry other)
+		{
+			return true && Width.Equals (other.Width) && XOffset.Equals (other.XOffset) && YOffset.Equals (other.YOffset);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is GlyphGeometry && Equals ((GlyphGeometry) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ Width.GetHashCode () ^ XOffset.GetHashCode () ^ YOffset.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/GlyphInfo.cs

@@ -0,0 +1,47 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct GlyphInfo : IEquatable<GlyphInfo> {
+
+		public uint Glyph;
+		public Pango.GlyphGeometry Geometry;
+		public Pango.GlyphVisAttr Attr;
+
+		public static Pango.GlyphInfo Zero = new Pango.GlyphInfo ();
+
+		public static Pango.GlyphInfo New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Pango.GlyphInfo.Zero;
+			return (Pango.GlyphInfo) Marshal.PtrToStructure (raw, typeof (Pango.GlyphInfo));
+		}
+
+		public bool Equals (GlyphInfo other)
+		{
+			return true && Glyph.Equals (other.Glyph) && Geometry.Equals (other.Geometry) && Attr.Equals (other.Attr);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is GlyphInfo && Equals ((GlyphInfo) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ Glyph.GetHashCode () ^ Geometry.GetHashCode () ^ Attr.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/GlyphItem.cs

@@ -0,0 +1,141 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct GlyphItem : IEquatable<GlyphItem> {
+
+		private IntPtr _item;
+		public Pango.Item Item {
+			get {
+				return _item == IntPtr.Zero ? null : (Pango.Item) GLib.Opaque.GetOpaque (_item, typeof (Pango.Item), false);
+			}
+			set {
+				_item = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+		private IntPtr _glyphs;
+		public Pango.GlyphString Glyphs {
+			get {
+				return _glyphs == IntPtr.Zero ? null : (Pango.GlyphString) GLib.Opaque.GetOpaque (_glyphs, typeof (Pango.GlyphString), false);
+			}
+			set {
+				_glyphs = value == null ? IntPtr.Zero : value.Handle;
+			}
+		}
+
+		public static Pango.GlyphItem Zero = new Pango.GlyphItem ();
+
+		public static Pango.GlyphItem New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Pango.GlyphItem.Zero;
+			return (Pango.GlyphItem) Marshal.PtrToStructure (raw, typeof (Pango.GlyphItem));
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_glyph_item_get_logical_widths(IntPtr raw, IntPtr text, out int logical_widths);
+		static d_pango_glyph_item_get_logical_widths pango_glyph_item_get_logical_widths = FuncLoader.LoadFunction<d_pango_glyph_item_get_logical_widths>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_item_get_logical_widths"));
+
+		public int GetLogicalWidths(string text) {
+			IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<Pango.GlyphItem>());
+			System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+			int logical_widths;
+			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
+			pango_glyph_item_get_logical_widths(this_as_native, native_text, out logical_widths);
+			ReadNative (this_as_native, ref this);
+			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+			GLib.Marshaller.Free (native_text);
+			return logical_widths;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_glyph_item_get_type();
+		static d_pango_glyph_item_get_type pango_glyph_item_get_type = FuncLoader.LoadFunction<d_pango_glyph_item_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_item_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_glyph_item_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_glyph_item_letter_space(IntPtr raw, IntPtr text, IntPtr log_attrs, int letter_spacing);
+		static d_pango_glyph_item_letter_space pango_glyph_item_letter_space = FuncLoader.LoadFunction<d_pango_glyph_item_letter_space>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_item_letter_space"));
+
+		public void LetterSpace(string text, Pango.LogAttr log_attrs, int letter_spacing) {
+			IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<Pango.GlyphItem>());
+			System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
+			IntPtr native_log_attrs = GLib.Marshaller.StructureToPtrAlloc (log_attrs);
+			pango_glyph_item_letter_space(this_as_native, native_text, native_log_attrs, letter_spacing);
+			ReadNative (this_as_native, ref this);
+			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+			GLib.Marshaller.Free (native_text);
+			Marshal.FreeHGlobal (native_log_attrs);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_glyph_item_split(IntPtr raw, IntPtr text, int split_index);
+		static d_pango_glyph_item_split pango_glyph_item_split = FuncLoader.LoadFunction<d_pango_glyph_item_split>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_item_split"));
+
+		public Pango.GlyphItem Split(string text, int split_index) {
+			IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<Pango.GlyphItem>());
+			System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
+			IntPtr raw_ret = pango_glyph_item_split(this_as_native, native_text, split_index);
+			Pango.GlyphItem ret = Pango.GlyphItem.New (raw_ret);
+			ReadNative (this_as_native, ref this);
+			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+			GLib.Marshaller.Free (native_text);
+			return ret;
+		}
+
+		static void ReadNative (IntPtr native, ref Pango.GlyphItem target)
+		{
+			target = New (native);
+		}
+
+		public bool Equals (GlyphItem other)
+		{
+			return true && Item.Equals (other.Item) && Glyphs.Equals (other.Glyphs);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is GlyphItem && Equals ((GlyphItem) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ Item.GetHashCode () ^ Glyphs.GetHashCode ();
+		}
+
+		public static explicit operator GLib.Value (Pango.GlyphItem boxed)
+		{
+			GLib.Value val = GLib.Value.Empty;
+			val.Init (Pango.GlyphItem.GType);
+			val.Val = boxed;
+			return val;
+		}
+
+		public static explicit operator Pango.GlyphItem (GLib.Value val)
+		{
+			return (Pango.GlyphItem) val.Val;
+		}
+
+		[Obsolete("This is a no-op")]
+		public Pango.GlyphItem Free () {
+			return this;
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/GlyphItemIter.cs

@@ -0,0 +1,146 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct GlyphItemIter : IEquatable<GlyphItemIter> {
+
+		private IntPtr _glyph_item;
+
+		public Pango.GlyphItem glyph_item {
+			get { return Pango.GlyphItem.New (_glyph_item); }
+		}
+		public string Text;
+		public int StartGlyph;
+		public int StartIndex;
+		public int StartChar;
+		public int EndGlyph;
+		public int EndIndex;
+		public int EndChar;
+
+		public static Pango.GlyphItemIter Zero = new Pango.GlyphItemIter ();
+
+		public static Pango.GlyphItemIter New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Pango.GlyphItemIter.Zero;
+			return (Pango.GlyphItemIter) Marshal.PtrToStructure (raw, typeof (Pango.GlyphItemIter));
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_glyph_item_iter_get_type();
+		static d_pango_glyph_item_iter_get_type pango_glyph_item_iter_get_type = FuncLoader.LoadFunction<d_pango_glyph_item_iter_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_item_iter_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_glyph_item_iter_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_glyph_item_iter_init_end(IntPtr raw, IntPtr glyph_item, IntPtr text);
+		static d_pango_glyph_item_iter_init_end pango_glyph_item_iter_init_end = FuncLoader.LoadFunction<d_pango_glyph_item_iter_init_end>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_item_iter_init_end"));
+
+		public bool InitEnd(Pango.GlyphItem glyph_item, string text) {
+			IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<Pango.GlyphItemIter>());
+			System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+			IntPtr native_glyph_item = GLib.Marshaller.StructureToPtrAlloc (glyph_item);
+			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
+			bool raw_ret = pango_glyph_item_iter_init_end(this_as_native, native_glyph_item, native_text);
+			bool ret = raw_ret;
+			ReadNative (this_as_native, ref this);
+			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+			Marshal.FreeHGlobal (native_glyph_item);
+			GLib.Marshaller.Free (native_text);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_glyph_item_iter_init_start(IntPtr raw, IntPtr glyph_item, IntPtr text);
+		static d_pango_glyph_item_iter_init_start pango_glyph_item_iter_init_start = FuncLoader.LoadFunction<d_pango_glyph_item_iter_init_start>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_item_iter_init_start"));
+
+		public bool InitStart(Pango.GlyphItem glyph_item, string text) {
+			IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<Pango.GlyphItemIter>());
+			System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+			IntPtr native_glyph_item = GLib.Marshaller.StructureToPtrAlloc (glyph_item);
+			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
+			bool raw_ret = pango_glyph_item_iter_init_start(this_as_native, native_glyph_item, native_text);
+			bool ret = raw_ret;
+			ReadNative (this_as_native, ref this);
+			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+			Marshal.FreeHGlobal (native_glyph_item);
+			GLib.Marshaller.Free (native_text);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_glyph_item_iter_next_cluster(IntPtr raw);
+		static d_pango_glyph_item_iter_next_cluster pango_glyph_item_iter_next_cluster = FuncLoader.LoadFunction<d_pango_glyph_item_iter_next_cluster>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_item_iter_next_cluster"));
+
+		public bool NextCluster() {
+			IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<Pango.GlyphItemIter>());
+			System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+			bool raw_ret = pango_glyph_item_iter_next_cluster(this_as_native);
+			bool ret = raw_ret;
+			ReadNative (this_as_native, ref this);
+			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_pango_glyph_item_iter_prev_cluster(IntPtr raw);
+		static d_pango_glyph_item_iter_prev_cluster pango_glyph_item_iter_prev_cluster = FuncLoader.LoadFunction<d_pango_glyph_item_iter_prev_cluster>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_item_iter_prev_cluster"));
+
+		public bool PrevCluster() {
+			IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<Pango.GlyphItemIter>());
+			System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+			bool raw_ret = pango_glyph_item_iter_prev_cluster(this_as_native);
+			bool ret = raw_ret;
+			ReadNative (this_as_native, ref this);
+			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+			return ret;
+		}
+
+		static void ReadNative (IntPtr native, ref Pango.GlyphItemIter target)
+		{
+			target = New (native);
+		}
+
+		public bool Equals (GlyphItemIter other)
+		{
+			return true && glyph_item.Equals (other.glyph_item) && Text.Equals (other.Text) && StartGlyph.Equals (other.StartGlyph) && StartIndex.Equals (other.StartIndex) && StartChar.Equals (other.StartChar) && EndGlyph.Equals (other.EndGlyph) && EndIndex.Equals (other.EndIndex) && EndChar.Equals (other.EndChar);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is GlyphItemIter && Equals ((GlyphItemIter) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ glyph_item.GetHashCode () ^ Text.GetHashCode () ^ StartGlyph.GetHashCode () ^ StartIndex.GetHashCode () ^ StartChar.GetHashCode () ^ EndGlyph.GetHashCode () ^ EndIndex.GetHashCode () ^ EndChar.GetHashCode ();
+		}
+
+		public static explicit operator GLib.Value (Pango.GlyphItemIter boxed)
+		{
+			GLib.Value val = GLib.Value.Empty;
+			val.Init (Pango.GlyphItemIter.GType);
+			val.Val = boxed;
+			return val;
+		}
+
+		public static explicit operator Pango.GlyphItemIter (GLib.Value val)
+		{
+			return (Pango.GlyphItemIter) val.Val;
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/GlyphString.cs

@@ -0,0 +1,240 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class GlyphString : GLib.Opaque {
+
+		public int NumGlyphs {
+			get {
+				unsafe {
+					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("num_glyphs"));
+					return (*raw_ptr);
+				}
+			}
+			set {
+				unsafe {
+					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("num_glyphs"));
+					*raw_ptr = value;
+				}
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_glyph_string_copy(IntPtr raw);
+		static d_pango_glyph_string_copy pango_glyph_string_copy = FuncLoader.LoadFunction<d_pango_glyph_string_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_string_copy"));
+
+		public Pango.GlyphString Copy() {
+			IntPtr raw_ret = pango_glyph_string_copy(Handle);
+			Pango.GlyphString ret = raw_ret == IntPtr.Zero ? null : (Pango.GlyphString) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.GlyphString), true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_glyph_string_extents(IntPtr raw, IntPtr font, IntPtr ink_rect, IntPtr logical_rect);
+		static d_pango_glyph_string_extents pango_glyph_string_extents = FuncLoader.LoadFunction<d_pango_glyph_string_extents>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_string_extents"));
+
+		public void Extents(Pango.Font font, Pango.Rectangle ink_rect, Pango.Rectangle logical_rect) {
+			IntPtr native_ink_rect = GLib.Marshaller.StructureToPtrAlloc (ink_rect);
+			IntPtr native_logical_rect = GLib.Marshaller.StructureToPtrAlloc (logical_rect);
+			pango_glyph_string_extents(Handle, font == null ? IntPtr.Zero : font.Handle, native_ink_rect, native_logical_rect);
+			Marshal.FreeHGlobal (native_ink_rect);
+			Marshal.FreeHGlobal (native_logical_rect);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_glyph_string_extents_range(IntPtr raw, int start, int end, IntPtr font, IntPtr ink_rect, IntPtr logical_rect);
+		static d_pango_glyph_string_extents_range pango_glyph_string_extents_range = FuncLoader.LoadFunction<d_pango_glyph_string_extents_range>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_string_extents_range"));
+
+		public void ExtentsRange(int start, int end, Pango.Font font, Pango.Rectangle ink_rect, Pango.Rectangle logical_rect) {
+			IntPtr native_ink_rect = GLib.Marshaller.StructureToPtrAlloc (ink_rect);
+			IntPtr native_logical_rect = GLib.Marshaller.StructureToPtrAlloc (logical_rect);
+			pango_glyph_string_extents_range(Handle, start, end, font == null ? IntPtr.Zero : font.Handle, native_ink_rect, native_logical_rect);
+			Marshal.FreeHGlobal (native_ink_rect);
+			Marshal.FreeHGlobal (native_logical_rect);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_glyph_string_get_logical_widths(IntPtr raw, IntPtr text, int length, int embedding_level, out int logical_widths);
+		static d_pango_glyph_string_get_logical_widths pango_glyph_string_get_logical_widths = FuncLoader.LoadFunction<d_pango_glyph_string_get_logical_widths>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_string_get_logical_widths"));
+
+		public int GetLogicalWidths(string text, int embedding_level) {
+			int logical_widths;
+			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
+			pango_glyph_string_get_logical_widths(Handle, native_text, System.Text.Encoding.UTF8.GetByteCount (text), embedding_level, out logical_widths);
+			GLib.Marshaller.Free (native_text);
+			return logical_widths;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_glyph_string_get_type();
+		static d_pango_glyph_string_get_type pango_glyph_string_get_type = FuncLoader.LoadFunction<d_pango_glyph_string_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_string_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_glyph_string_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_pango_glyph_string_get_width(IntPtr raw);
+		static d_pango_glyph_string_get_width pango_glyph_string_get_width = FuncLoader.LoadFunction<d_pango_glyph_string_get_width>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_string_get_width"));
+
+		public int Width { 
+			get {
+				int raw_ret = pango_glyph_string_get_width(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_glyph_string_index_to_x(IntPtr raw, IntPtr text, int length, IntPtr analysis, int index_, bool trailing, out int x_pos);
+		static d_pango_glyph_string_index_to_x pango_glyph_string_index_to_x = FuncLoader.LoadFunction<d_pango_glyph_string_index_to_x>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_string_index_to_x"));
+
+		public int IndexToX(string text, Pango.Analysis analysis, int index_, bool trailing) {
+			int x_pos;
+			IntPtr native_analysis = GLib.Marshaller.StructureToPtrAlloc (analysis);
+			pango_glyph_string_index_to_x(Handle, GLib.Marshaller.StringToPtrGStrdup(text), System.Text.Encoding.UTF8.GetByteCount (text), native_analysis, index_, trailing, out x_pos);
+			Marshal.FreeHGlobal (native_analysis);
+			return x_pos;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_glyph_string_set_size(IntPtr raw, int new_len);
+		static d_pango_glyph_string_set_size pango_glyph_string_set_size = FuncLoader.LoadFunction<d_pango_glyph_string_set_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_string_set_size"));
+
+		public int Size { 
+			set {
+				pango_glyph_string_set_size(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_glyph_string_x_to_index(IntPtr raw, IntPtr text, int length, IntPtr analysis, int x_pos, out int index_, out int trailing);
+		static d_pango_glyph_string_x_to_index pango_glyph_string_x_to_index = FuncLoader.LoadFunction<d_pango_glyph_string_x_to_index>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_string_x_to_index"));
+
+		public void XToIndex(string text, Pango.Analysis analysis, int x_pos, out int index_, out int trailing) {
+			IntPtr native_analysis = GLib.Marshaller.StructureToPtrAlloc (analysis);
+			pango_glyph_string_x_to_index(Handle, GLib.Marshaller.StringToPtrGStrdup(text), System.Text.Encoding.UTF8.GetByteCount (text), native_analysis, x_pos, out index_, out trailing);
+			Marshal.FreeHGlobal (native_analysis);
+		}
+
+		public GlyphString(IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_glyph_string_new();
+		static d_pango_glyph_string_new pango_glyph_string_new = FuncLoader.LoadFunction<d_pango_glyph_string_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_string_new"));
+
+		public GlyphString () 
+		{
+			Raw = pango_glyph_string_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_glyph_string_free(IntPtr raw);
+		static d_pango_glyph_string_free pango_glyph_string_free = FuncLoader.LoadFunction<d_pango_glyph_string_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_glyph_string_free"));
+
+		protected override void Free (IntPtr raw)
+		{
+			pango_glyph_string_free (raw);
+		}
+
+		class FinalizerInfo {
+			IntPtr handle;
+			public uint timeoutHandlerId;
+
+			public FinalizerInfo (IntPtr handle)
+			{
+				this.handle = handle;
+			}
+
+			public bool Handler ()
+			{
+				pango_glyph_string_free (handle);
+				GLib.Timeout.Remove(timeoutHandlerId);
+				return false;
+			}
+		}
+
+		~GlyphString ()
+		{
+			if (!Owned)
+				return;
+			FinalizerInfo info = new FinalizerInfo (Handle);
+			info.timeoutHandlerId = GLib.Timeout.Add (50, new GLib.TimeoutHandler (info.Handler));
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("num_glyphs"
+							, 0
+							, (uint) sizeof( int ) // num_glyphs
+							, null
+							, "glyphs"
+							, (long) Marshal.OffsetOf<PangoGlyphString_num_glyphsAlign>("num_glyphs")
+							, 0
+							),
+						new GLib.AbiField("glyphs"
+							, -1
+							, (uint) sizeof( IntPtr ) // glyphs
+							, "num_glyphs"
+							, "log_clusters"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("log_clusters"
+							, -1
+							, (uint) sizeof( IntPtr ) // log_clusters
+							, "glyphs"
+							, "space"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("space"
+							, -1
+							, (uint) sizeof( int ) // space
+							, "log_clusters"
+							, null
+							, (long) Marshal.OffsetOf<PangoGlyphString_spaceAlign>("space")
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct PangoGlyphString_num_glyphsAlign
+		{
+			sbyte f1;
+			private int num_glyphs;
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct PangoGlyphString_spaceAlign
+		{
+			sbyte f1;
+			private int space;
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/GlyphVisAttr.cs

@@ -0,0 +1,46 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct GlyphVisAttr : IEquatable<GlyphVisAttr> {
+
+		private uint _bitfield0;
+
+
+		public static Pango.GlyphVisAttr Zero = new Pango.GlyphVisAttr ();
+
+		public static Pango.GlyphVisAttr New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return Pango.GlyphVisAttr.Zero;
+			return (Pango.GlyphVisAttr) Marshal.PtrToStructure (raw, typeof (Pango.GlyphVisAttr));
+		}
+
+		public bool Equals (GlyphVisAttr other)
+		{
+			return true && _bitfield0.Equals (other._bitfield0);
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is GlyphVisAttr && Equals ((GlyphVisAttr) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode () ^ _bitfield0.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/Gravity.cs

@@ -0,0 +1,32 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Pango.GravityGType))]
+	public enum Gravity {
+
+		South,
+		East,
+		North,
+		West,
+		Auto,
+	}
+
+	internal class GravityGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_gravity_get_type();
+		static d_pango_gravity_get_type pango_gravity_get_type = FuncLoader.LoadFunction<d_pango_gravity_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_gravity_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (pango_gravity_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/GravityHint.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[GLib.GType (typeof (Pango.GravityHintGType))]
+	public enum GravityHint {
+
+		Natural,
+		Strong,
+		Line,
+	}
+
+	internal class GravityHintGType {
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_gravity_hint_get_type();
+		static d_pango_gravity_hint_get_type pango_gravity_hint_get_type = FuncLoader.LoadFunction<d_pango_gravity_hint_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_gravity_hint_get_type"));
+
+		public static GLib.GType GType {
+			get {
+				return new GLib.GType (pango_gravity_hint_get_type ());
+			}
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/PangoSharp/Generated/Pango/Item.cs

@@ -0,0 +1,229 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace Pango {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Item : GLib.Opaque {
+
+		public int Offset {
+			get {
+				unsafe {
+					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("offset"));
+					return (*raw_ptr);
+				}
+			}
+			set {
+				unsafe {
+					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("offset"));
+					*raw_ptr = value;
+				}
+			}
+		}
+
+		public int Length {
+			get {
+				unsafe {
+					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("length"));
+					return (*raw_ptr);
+				}
+			}
+			set {
+				unsafe {
+					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("length"));
+					*raw_ptr = value;
+				}
+			}
+		}
+
+		public int NumChars {
+			get {
+				unsafe {
+					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("num_chars"));
+					return (*raw_ptr);
+				}
+			}
+			set {
+				unsafe {
+					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("num_chars"));
+					*raw_ptr = value;
+				}
+			}
+		}
+
+		public Pango.Analysis Analysis {
+			get {
+				unsafe {
+					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("analysis"));
+					return Pango.Analysis.New ((*raw_ptr));
+				}
+			}
+			set {
+				unsafe {
+					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("analysis"));
+					*raw_ptr = GLib.Marshaller.StructureToPtrAlloc (value);
+				}
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_item_copy(IntPtr raw);
+		static d_pango_item_copy pango_item_copy = FuncLoader.LoadFunction<d_pango_item_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_item_copy"));
+
+		public Pango.Item Copy() {
+			IntPtr raw_ret = pango_item_copy(Handle);
+			Pango.Item ret = raw_ret == IntPtr.Zero ? null : (Pango.Item) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.Item), true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_item_get_type();
+		static d_pango_item_get_type pango_item_get_type = FuncLoader.LoadFunction<d_pango_item_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_item_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = pango_item_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_item_split(IntPtr raw, int split_index, int split_offset);
+		static d_pango_item_split pango_item_split = FuncLoader.LoadFunction<d_pango_item_split>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_item_split"));
+
+		public Pango.Item Split(int split_index, int split_offset) {
+			IntPtr raw_ret = pango_item_split(Handle, split_index, split_offset);
+			Pango.Item ret = raw_ret == IntPtr.Zero ? null : (Pango.Item) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.Item), false);
+			return ret;
+		}
+
+		public Item(IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_pango_item_new();
+		static d_pango_item_new pango_item_new = FuncLoader.LoadFunction<d_pango_item_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_item_new"));
+
+		public Item () 
+		{
+			Raw = pango_item_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_pango_item_free(IntPtr raw);
+		static d_pango_item_free pango_item_free = FuncLoader.LoadFunction<d_pango_item_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Pango), "pango_item_free"));
+
+		protected override void Free (IntPtr raw)
+		{
+			pango_item_free (raw);
+		}
+
+		class FinalizerInfo {
+			IntPtr handle;
+			public uint timeoutHandlerId;
+
+			public FinalizerInfo (IntPtr handle)
+			{
+				this.handle = handle;
+			}
+
+			public bool Handler ()
+			{
+				pango_item_free (handle);
+				GLib.Timeout.Remove(timeoutHandlerId);
+				return false;
+			}
+		}
+
+		~Item ()
+		{
+			if (!Owned)
+				return;
+			FinalizerInfo info = new FinalizerInfo (Handle);
+			info.timeoutHandlerId = GLib.Timeout.Add (50, new GLib.TimeoutHandler (info.Handler));
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("offset"
+							, 0
+							, (uint) sizeof( int ) // offset
+							, null
+							, "length"
+							, (long) Marshal.OffsetOf<PangoItem_offsetAlign>("offset")
+							, 0
+							),
+						new GLib.AbiField("length"
+							, -1
+							, (uint) sizeof( int ) // length
+							, "offset"
+							, "num_chars"
+							, (long) Marshal.OffsetOf<PangoItem_lengthAlign>("length")
+							, 0
+							),
+						new GLib.AbiField("num_chars"
+							, -1
+							, (uint) sizeof( int ) // num_chars
+							, "length"
+							, "analysis"
+							, (long) Marshal.OffsetOf<PangoItem_num_charsAlign>("num_chars")
+							, 0
+							),
+						new GLib.AbiField("analysis"
+							, -1
+							, (uint) Marshal.SizeOf<Pango.Analysis>() // analysis
+							, "num_chars"
+							, null
+							, (long) Marshal.OffsetOf<PangoItem_analysisAlign>("analysis")
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct PangoItem_offsetAlign
+		{
+			sbyte f1;
+			private int offset;
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct PangoItem_lengthAlign
+		{
+			sbyte f1;
+			private int length;
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct PangoItem_num_charsAlign
+		{
+			sbyte f1;
+			private int num_chars;
+		}
+
+		[StructLayout(LayoutKind.Sequential)]
+		public struct PangoItem_analysisAlign
+		{
+			sbyte f1;
+			private Pango.Analysis analysis;
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}