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

namespace GtkSource {

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

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

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

		protected Completion() : base(IntPtr.Zero)
		{
			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
		}

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

		[GLib.Property ("view")]
		public GtkSource.SourceView View {
			get  {
				IntPtr raw_ret = gtk_source_completion_get_view(Handle);
				GtkSource.SourceView ret = GLib.Object.GetObject(raw_ret) as GtkSource.SourceView;
				return ret;
			}
		}

		[GLib.Property ("remember-info-visibility")]
		public bool RememberInfoVisibility {
			get {
				GLib.Value val = GetProperty ("remember-info-visibility");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("remember-info-visibility", val);
				val.Dispose ();
			}
		}

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

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

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

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

		[GLib.Property ("auto-complete-delay")]
		public uint AutoCompleteDelay {
			get {
				GLib.Value val = GetProperty ("auto-complete-delay");
				uint ret = (uint) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("auto-complete-delay", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("provider-page-size")]
		public uint ProviderPageSize {
			get {
				GLib.Value val = GetProperty ("provider-page-size");
				uint ret = (uint) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("provider-page-size", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("proposal-page-size")]
		public uint ProposalPageSize {
			get {
				GLib.Value val = GetProperty ("proposal-page-size");
				uint ret = (uint) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("proposal-page-size", val);
				val.Dispose ();
			}
		}

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

		[GLib.Signal("activate-proposal")]
		public event System.EventHandler ActivateProposal {
			add {
				this.AddSignalHandler ("activate-proposal", value);
			}
			remove {
				this.RemoveSignalHandler ("activate-proposal", value);
			}
		}

		[GLib.Signal("populate-context")]
		public event GtkSource.PopulateContextHandler PopulateContext {
			add {
				this.AddSignalHandler ("populate-context", value, typeof (GtkSource.PopulateContextArgs));
			}
			remove {
				this.RemoveSignalHandler ("populate-context", value);
			}
		}

		[GLib.Signal("move-page")]
		public event GtkSource.MovePageHandler MovePage {
			add {
				this.AddSignalHandler ("move-page", value, typeof (GtkSource.MovePageArgs));
			}
			remove {
				this.RemoveSignalHandler ("move-page", value);
			}
		}

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

		[GLib.Signal("move-cursor")]
		public event GtkSource.MoveCursorHandler MoveCursor {
			add {
				this.AddSignalHandler ("move-cursor", value, typeof (GtkSource.MoveCursorArgs));
			}
			remove {
				this.RemoveSignalHandler ("move-cursor", value);
			}
		}

		static ProposalActivatedNativeDelegate ProposalActivated_cb_delegate;
		static ProposalActivatedNativeDelegate ProposalActivatedVMCallback {
			get {
				if (ProposalActivated_cb_delegate == null)
					ProposalActivated_cb_delegate = new ProposalActivatedNativeDelegate (ProposalActivated_cb);
				return ProposalActivated_cb_delegate;
			}
		}

		static void OverrideProposalActivated (GLib.GType gtype)
		{
			OverrideProposalActivated (gtype, ProposalActivatedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ProposalActivatedNativeDelegate (IntPtr inst, IntPtr provider, IntPtr proposal);

		static bool ProposalActivated_cb (IntPtr inst, IntPtr provider, IntPtr proposal)
		{
			try {
				Completion __obj = GLib.Object.GetObject (inst, false) as Completion;
				bool __result;
				__result = __obj.OnProposalActivated (GtkSource.CompletionProviderAdapter.GetObject (provider, false), GtkSource.CompletionProposalAdapter.GetObject (proposal, false));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverrideProposalActivated")]
		protected virtual bool OnProposalActivated (GtkSource.ICompletionProvider provider, GtkSource.ICompletionProposal proposal)
		{
			return InternalProposalActivated (provider, proposal);
		}

		private bool InternalProposalActivated (GtkSource.ICompletionProvider provider, GtkSource.ICompletionProposal proposal)
		{
			ProposalActivatedNativeDelegate unmanaged = class_abi.BaseOverride<ProposalActivatedNativeDelegate>(this.LookupGType(), "proposal_activated");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, provider == null ? IntPtr.Zero : ((provider is GLib.Object) ? (provider as GLib.Object).Handle : (provider as GtkSource.CompletionProviderAdapter).Handle), proposal == null ? IntPtr.Zero : ((proposal is GLib.Object) ? (proposal as GLib.Object).Handle : (proposal as GtkSource.CompletionProposalAdapter).Handle));
			return __result;
		}

		static ShowNativeDelegate Show_cb_delegate;
		static ShowNativeDelegate ShowVMCallback {
			get {
				if (Show_cb_delegate == null)
					Show_cb_delegate = new ShowNativeDelegate (Show_cb);
				return Show_cb_delegate;
			}
		}

		static void OverrideShow (GLib.GType gtype)
		{
			OverrideShow (gtype, ShowVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverrideShow")]
		protected virtual void OnShow ()
		{
			InternalShow ();
		}

		private void InternalShow ()
		{
			ShowNativeDelegate unmanaged = class_abi.BaseOverride<ShowNativeDelegate>(this.LookupGType(), "show");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static HiddenNativeDelegate Hidden_cb_delegate;
		static HiddenNativeDelegate HiddenVMCallback {
			get {
				if (Hidden_cb_delegate == null)
					Hidden_cb_delegate = new HiddenNativeDelegate (Hidden_cb);
				return Hidden_cb_delegate;
			}
		}

		static void OverrideHidden (GLib.GType gtype)
		{
			OverrideHidden (gtype, HiddenVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverrideHidden")]
		protected virtual void OnHidden ()
		{
			InternalHidden ();
		}

		private void InternalHidden ()
		{
			HiddenNativeDelegate unmanaged = class_abi.BaseOverride<HiddenNativeDelegate>(this.LookupGType(), "hide");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static PopulateContextNativeDelegate PopulateContext_cb_delegate;
		static PopulateContextNativeDelegate PopulateContextVMCallback {
			get {
				if (PopulateContext_cb_delegate == null)
					PopulateContext_cb_delegate = new PopulateContextNativeDelegate (PopulateContext_cb);
				return PopulateContext_cb_delegate;
			}
		}

		static void OverridePopulateContext (GLib.GType gtype)
		{
			OverridePopulateContext (gtype, PopulateContextVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void PopulateContextNativeDelegate (IntPtr inst, IntPtr context);

		static void PopulateContext_cb (IntPtr inst, IntPtr context)
		{
			try {
				Completion __obj = GLib.Object.GetObject (inst, false) as Completion;
				__obj.OnPopulateContext (GLib.Object.GetObject(context) as GtkSource.CompletionContext);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverridePopulateContext")]
		protected virtual void OnPopulateContext (GtkSource.CompletionContext context)
		{
			InternalPopulateContext (context);
		}

		private void InternalPopulateContext (GtkSource.CompletionContext context)
		{
			PopulateContextNativeDelegate unmanaged = class_abi.BaseOverride<PopulateContextNativeDelegate>(this.LookupGType(), "populate_context");
			if (unmanaged == null) return;

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

		static MoveCursorNativeDelegate MoveCursor_cb_delegate;
		static MoveCursorNativeDelegate MoveCursorVMCallback {
			get {
				if (MoveCursor_cb_delegate == null)
					MoveCursor_cb_delegate = new MoveCursorNativeDelegate (MoveCursor_cb);
				return MoveCursor_cb_delegate;
			}
		}

		static void OverrideMoveCursor (GLib.GType gtype)
		{
			OverrideMoveCursor (gtype, MoveCursorVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void MoveCursorNativeDelegate (IntPtr inst, int step, int num);

		static void MoveCursor_cb (IntPtr inst, int step, int num)
		{
			try {
				Completion __obj = GLib.Object.GetObject (inst, false) as Completion;
				__obj.OnMoveCursor ((Gtk.ScrollStep) step, num);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverrideMoveCursor")]
		protected virtual void OnMoveCursor (Gtk.ScrollStep step, int num)
		{
			InternalMoveCursor (step, num);
		}

		private void InternalMoveCursor (Gtk.ScrollStep step, int num)
		{
			MoveCursorNativeDelegate unmanaged = class_abi.BaseOverride<MoveCursorNativeDelegate>(this.LookupGType(), "move_cursor");
			if (unmanaged == null) return;

			unmanaged (this.Handle, (int) step, num);
		}

		static MovePageNativeDelegate MovePage_cb_delegate;
		static MovePageNativeDelegate MovePageVMCallback {
			get {
				if (MovePage_cb_delegate == null)
					MovePage_cb_delegate = new MovePageNativeDelegate (MovePage_cb);
				return MovePage_cb_delegate;
			}
		}

		static void OverrideMovePage (GLib.GType gtype)
		{
			OverrideMovePage (gtype, MovePageVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void MovePageNativeDelegate (IntPtr inst, int step, int num);

		static void MovePage_cb (IntPtr inst, int step, int num)
		{
			try {
				Completion __obj = GLib.Object.GetObject (inst, false) as Completion;
				__obj.OnMovePage ((Gtk.ScrollStep) step, num);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverrideMovePage")]
		protected virtual void OnMovePage (Gtk.ScrollStep step, int num)
		{
			InternalMovePage (step, num);
		}

		private void InternalMovePage (Gtk.ScrollStep step, int num)
		{
			MovePageNativeDelegate unmanaged = class_abi.BaseOverride<MovePageNativeDelegate>(this.LookupGType(), "move_page");
			if (unmanaged == null) return;

			unmanaged (this.Handle, (int) step, num);
		}

		static ActivateProposalNativeDelegate ActivateProposal_cb_delegate;
		static ActivateProposalNativeDelegate ActivateProposalVMCallback {
			get {
				if (ActivateProposal_cb_delegate == null)
					ActivateProposal_cb_delegate = new ActivateProposalNativeDelegate (ActivateProposal_cb);
				return ActivateProposal_cb_delegate;
			}
		}

		static void OverrideActivateProposal (GLib.GType gtype)
		{
			OverrideActivateProposal (gtype, ActivateProposalVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverrideActivateProposal")]
		protected virtual void OnActivateProposal ()
		{
			InternalActivateProposal ();
		}

		private void InternalActivateProposal ()
		{
			ActivateProposalNativeDelegate unmanaged = class_abi.BaseOverride<ActivateProposalNativeDelegate>(this.LookupGType(), "activate_proposal");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _class_abi = null;
		static public unsafe new GLib.AbiStruct class_abi {
			get {
				if (_class_abi == null)
					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("proposal_activated"
							, GLib.Object.class_abi.Fields
							, (uint) sizeof( IntPtr ) // proposal_activated
							, null
							, "show"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("show"
							, -1
							, (uint) sizeof( IntPtr ) // show
							, "proposal_activated"
							, "hide"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("hide"
							, -1
							, (uint) sizeof( IntPtr ) // hide
							, "show"
							, "populate_context"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("populate_context"
							, -1
							, (uint) sizeof( IntPtr ) // populate_context
							, "hide"
							, "move_cursor"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("move_cursor"
							, -1
							, (uint) sizeof( IntPtr ) // move_cursor
							, "populate_context"
							, "move_page"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("move_page"
							, -1
							, (uint) sizeof( IntPtr ) // move_page
							, "move_cursor"
							, "activate_proposal"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("activate_proposal"
							, -1
							, (uint) sizeof( IntPtr ) // activate_proposal
							, "move_page"
							, "padding"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("padding"
							, -1
							, (uint) sizeof( IntPtr ) * 20 // padding
							, "activate_proposal"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_source_completion_add_provider(IntPtr raw, IntPtr provider, out IntPtr error);
		static d_gtk_source_completion_add_provider gtk_source_completion_add_provider = FuncLoader.LoadFunction<d_gtk_source_completion_add_provider>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_add_provider"));

		public unsafe bool AddProvider(GtkSource.ICompletionProvider provider) {
			IntPtr error = IntPtr.Zero;
			bool raw_ret = gtk_source_completion_add_provider(Handle, provider == null ? IntPtr.Zero : ((provider is GLib.Object) ? (provider as GLib.Object).Handle : (provider as GtkSource.CompletionProviderAdapter).Handle), out error);
			bool ret = raw_ret;
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

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

		public void BlockInteractive() {
			gtk_source_completion_block_interactive(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_source_completion_create_context(IntPtr raw, IntPtr position);
		static d_gtk_source_completion_create_context gtk_source_completion_create_context = FuncLoader.LoadFunction<d_gtk_source_completion_create_context>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_create_context"));

		public GtkSource.CompletionContext CreateContext(Gtk.TextIter position) {
			IntPtr native_position = GLib.Marshaller.StructureToPtrAlloc (position);
			IntPtr raw_ret = gtk_source_completion_create_context(Handle, native_position);
			GtkSource.CompletionContext ret = GLib.Object.GetObject(raw_ret) as GtkSource.CompletionContext;
			Marshal.FreeHGlobal (native_position);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_gtk_source_completion_error_quark();
		static d_gtk_source_completion_error_quark gtk_source_completion_error_quark = FuncLoader.LoadFunction<d_gtk_source_completion_error_quark>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_error_quark"));

		public static int ErrorQuark() {
			int raw_ret = gtk_source_completion_error_quark();
			int ret = raw_ret;
			return ret;
		}

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

		public GtkSource.CompletionInfo InfoWindow { 
			get {
				IntPtr raw_ret = gtk_source_completion_get_info_window(Handle);
				GtkSource.CompletionInfo ret = GLib.Object.GetObject(raw_ret) as GtkSource.CompletionInfo;
				return ret;
			}
		}

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

		public GtkSource.ICompletionProvider[] Providers { 
			get {
				IntPtr raw_ret = gtk_source_completion_get_providers(Handle);
				GtkSource.ICompletionProvider[] ret = GLib.Marshaller.ListPtrToArray<GtkSource.ICompletionProvider, GtkSource.ICompletionProvider> (raw_ret, false, false);
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_source_completion_get_type();
		static d_gtk_source_completion_get_type gtk_source_completion_get_type = FuncLoader.LoadFunction<d_gtk_source_completion_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_get_type"));

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

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

		public void Hide() {
			gtk_source_completion_hide(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_source_completion_remove_provider(IntPtr raw, IntPtr provider, out IntPtr error);
		static d_gtk_source_completion_remove_provider gtk_source_completion_remove_provider = FuncLoader.LoadFunction<d_gtk_source_completion_remove_provider>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_remove_provider"));

		public unsafe bool RemoveProvider(GtkSource.ICompletionProvider provider) {
			IntPtr error = IntPtr.Zero;
			bool raw_ret = gtk_source_completion_remove_provider(Handle, provider == null ? IntPtr.Zero : ((provider is GLib.Object) ? (provider as GLib.Object).Handle : (provider as GtkSource.CompletionProviderAdapter).Handle), out error);
			bool ret = raw_ret;
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_source_completion_start(IntPtr raw, IntPtr providers, IntPtr context);
		static d_gtk_source_completion_start gtk_source_completion_start = FuncLoader.LoadFunction<d_gtk_source_completion_start>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_start"));

		public bool Start(GLib.List providers, GtkSource.CompletionContext context) {
			bool raw_ret = gtk_source_completion_start(Handle, providers == null ? IntPtr.Zero : providers.Handle, context == null ? IntPtr.Zero : context.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public void UnblockInteractive() {
			gtk_source_completion_unblock_interactive(Handle);
		}


		static Completion ()
		{
			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
		}

		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _abi_info = null;
		static public unsafe new GLib.AbiStruct abi_info {
			get {
				if (_abi_info == null)
					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("priv"
							, GLib.Object.abi_info.Fields
							, (uint) sizeof( IntPtr ) // priv
							, null
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}