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

namespace Gtk {

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

#region Autogenerated code
	public partial class Range : Gtk.Widget {

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

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

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

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

		[GLib.Property ("adjustment")]
		public Gtk.Adjustment Adjustment {
			get  {
				IntPtr raw_ret = gtk_range_get_adjustment(Handle);
				Gtk.Adjustment ret = GLib.Object.GetObject(raw_ret) as Gtk.Adjustment;
				return ret;
			}
			set  {
				gtk_range_set_adjustment(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

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

		[GLib.Property ("inverted")]
		public bool Inverted {
			get  {
				bool raw_ret = gtk_range_get_inverted(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_range_set_inverted(Handle, value);
			}
		}

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

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

		[GLib.Property ("lower-stepper-sensitivity")]
		public Gtk.SensitivityType LowerStepperSensitivity {
			get  {
				int raw_ret = gtk_range_get_lower_stepper_sensitivity(Handle);
				Gtk.SensitivityType ret = (Gtk.SensitivityType) raw_ret;
				return ret;
			}
			set  {
				gtk_range_set_lower_stepper_sensitivity(Handle, (int) value);
			}
		}

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

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

		[GLib.Property ("upper-stepper-sensitivity")]
		public Gtk.SensitivityType UpperStepperSensitivity {
			get  {
				int raw_ret = gtk_range_get_upper_stepper_sensitivity(Handle);
				Gtk.SensitivityType ret = (Gtk.SensitivityType) raw_ret;
				return ret;
			}
			set  {
				gtk_range_set_upper_stepper_sensitivity(Handle, (int) value);
			}
		}

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

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

		[GLib.Property ("show-fill-level")]
		public bool ShowFillLevel {
			get  {
				bool raw_ret = gtk_range_get_show_fill_level(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_range_set_show_fill_level(Handle, value);
			}
		}

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

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

		[GLib.Property ("restrict-to-fill-level")]
		public bool RestrictToFillLevel {
			get  {
				bool raw_ret = gtk_range_get_restrict_to_fill_level(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_range_set_restrict_to_fill_level(Handle, value);
			}
		}

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

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

		[GLib.Property ("fill-level")]
		public double FillLevel {
			get  {
				double raw_ret = gtk_range_get_fill_level(Handle);
				double ret = raw_ret;
				return ret;
			}
			set  {
				gtk_range_set_fill_level(Handle, value);
			}
		}

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

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

		[GLib.Property ("round-digits")]
		public int RoundDigits {
			get  {
				int raw_ret = gtk_range_get_round_digits(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_range_set_round_digits(Handle, value);
			}
		}

		[Obsolete]
		public int SliderWidth {
			get {
				var val = (int)StyleGetProperty("slider-width");
				return val;
			}
		}

		[Obsolete]
		public int TroughBorder {
			get {
				var val = (int)StyleGetProperty("trough-border");
				return val;
			}
		}

		[Obsolete]
		public int StepperSize {
			get {
				var val = (int)StyleGetProperty("stepper-size");
				return val;
			}
		}

		[Obsolete]
		public int StepperSpacing {
			get {
				var val = (int)StyleGetProperty("stepper-spacing");
				return val;
			}
		}

		[Obsolete]
		public int ArrowDisplacementX {
			get {
				var val = (int)StyleGetProperty("arrow-displacement-x");
				return val;
			}
		}

		[Obsolete]
		public int ArrowDisplacementY {
			get {
				var val = (int)StyleGetProperty("arrow-displacement-y");
				return val;
			}
		}

		[Obsolete]
		public bool TroughUnderSteppers {
			get {
				var val = (bool)StyleGetProperty("trough-under-steppers");
				return val;
			}
		}

		[Obsolete]
		public float ArrowScaling {
			get {
				var val = (float)StyleGetProperty("arrow-scaling");
				return val;
			}
		}

		[GLib.Signal("change-value")]
		public event Gtk.ChangeValueHandler ChangeValue {
			add {
				this.AddSignalHandler ("change-value", value, typeof (Gtk.ChangeValueArgs));
			}
			remove {
				this.RemoveSignalHandler ("change-value", value);
			}
		}

		[GLib.Signal("move-slider")]
		public event Gtk.MoveSliderHandler MoveSlider {
			add {
				this.AddSignalHandler ("move-slider", value, typeof (Gtk.MoveSliderArgs));
			}
			remove {
				this.RemoveSignalHandler ("move-slider", value);
			}
		}

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

		[GLib.Signal("adjust-bounds")]
		public event Gtk.AdjustBoundsHandler AdjustBounds {
			add {
				this.AddSignalHandler ("adjust-bounds", value, typeof (Gtk.AdjustBoundsArgs));
			}
			remove {
				this.RemoveSignalHandler ("adjust-bounds", value);
			}
		}

		static ValueChangedNativeDelegate ValueChanged_cb_delegate;
		static ValueChangedNativeDelegate ValueChangedVMCallback {
			get {
				if (ValueChanged_cb_delegate == null)
					ValueChanged_cb_delegate = new ValueChangedNativeDelegate (ValueChanged_cb);
				return ValueChanged_cb_delegate;
			}
		}

		static void OverrideValueChanged (GLib.GType gtype)
		{
			OverrideValueChanged (gtype, ValueChangedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Range), ConnectionMethod="OverrideValueChanged")]
		protected virtual void OnValueChanged ()
		{
			InternalValueChanged ();
		}

		private void InternalValueChanged ()
		{
			ValueChangedNativeDelegate unmanaged = class_abi.BaseOverride<ValueChangedNativeDelegate>(this.LookupGType(), "value_changed");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static AdjustBoundsNativeDelegate AdjustBounds_cb_delegate;
		static AdjustBoundsNativeDelegate AdjustBoundsVMCallback {
			get {
				if (AdjustBounds_cb_delegate == null)
					AdjustBounds_cb_delegate = new AdjustBoundsNativeDelegate (AdjustBounds_cb);
				return AdjustBounds_cb_delegate;
			}
		}

		static void OverrideAdjustBounds (GLib.GType gtype)
		{
			OverrideAdjustBounds (gtype, AdjustBoundsVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void AdjustBoundsNativeDelegate (IntPtr inst, double new_value);

		static void AdjustBounds_cb (IntPtr inst, double new_value)
		{
			try {
				Range __obj = GLib.Object.GetObject (inst, false) as Range;
				__obj.OnAdjustBounds (new_value);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Range), ConnectionMethod="OverrideAdjustBounds")]
		protected virtual void OnAdjustBounds (double new_value)
		{
			InternalAdjustBounds (new_value);
		}

		private void InternalAdjustBounds (double new_value)
		{
			AdjustBoundsNativeDelegate unmanaged = class_abi.BaseOverride<AdjustBoundsNativeDelegate>(this.LookupGType(), "adjust_bounds");
			if (unmanaged == null) return;

			unmanaged (this.Handle, new_value);
		}

		static MoveSliderNativeDelegate MoveSlider_cb_delegate;
		static MoveSliderNativeDelegate MoveSliderVMCallback {
			get {
				if (MoveSlider_cb_delegate == null)
					MoveSlider_cb_delegate = new MoveSliderNativeDelegate (MoveSlider_cb);
				return MoveSlider_cb_delegate;
			}
		}

		static void OverrideMoveSlider (GLib.GType gtype)
		{
			OverrideMoveSlider (gtype, MoveSliderVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void MoveSliderNativeDelegate (IntPtr inst, int scroll);

		static void MoveSlider_cb (IntPtr inst, int scroll)
		{
			try {
				Range __obj = GLib.Object.GetObject (inst, false) as Range;
				__obj.OnMoveSlider ((Gtk.ScrollType) scroll);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Range), ConnectionMethod="OverrideMoveSlider")]
		protected virtual void OnMoveSlider (Gtk.ScrollType scroll)
		{
			InternalMoveSlider (scroll);
		}

		private void InternalMoveSlider (Gtk.ScrollType scroll)
		{
			MoveSliderNativeDelegate unmanaged = class_abi.BaseOverride<MoveSliderNativeDelegate>(this.LookupGType(), "move_slider");
			if (unmanaged == null) return;

			unmanaged (this.Handle, (int) scroll);
		}

		static GetRangeBorderNativeDelegate GetRangeBorder_cb_delegate;
		static GetRangeBorderNativeDelegate GetRangeBorderVMCallback {
			get {
				if (GetRangeBorder_cb_delegate == null)
					GetRangeBorder_cb_delegate = new GetRangeBorderNativeDelegate (GetRangeBorder_cb);
				return GetRangeBorder_cb_delegate;
			}
		}

		static void OverrideGetRangeBorder (GLib.GType gtype)
		{
			OverrideGetRangeBorder (gtype, GetRangeBorderVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetRangeBorderNativeDelegate (IntPtr inst, IntPtr border_);

		static void GetRangeBorder_cb (IntPtr inst, IntPtr border_)
		{
			try {
				Range __obj = GLib.Object.GetObject (inst, false) as Range;
				__obj.OnGetRangeBorder (Gtk.Border.New (border_));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Range), ConnectionMethod="OverrideGetRangeBorder")]
		protected virtual void OnGetRangeBorder (Gtk.Border border_)
		{
			InternalGetRangeBorder (border_);
		}

		private void InternalGetRangeBorder (Gtk.Border border_)
		{
			GetRangeBorderNativeDelegate unmanaged = class_abi.BaseOverride<GetRangeBorderNativeDelegate>(this.LookupGType(), "get_range_border");
			if (unmanaged == null) return;

			IntPtr native_border_ = GLib.Marshaller.StructureToPtrAlloc (border_);
			unmanaged (this.Handle, native_border_);
			Marshal.FreeHGlobal (native_border_);
		}

		static ChangeValueNativeDelegate ChangeValue_cb_delegate;
		static ChangeValueNativeDelegate ChangeValueVMCallback {
			get {
				if (ChangeValue_cb_delegate == null)
					ChangeValue_cb_delegate = new ChangeValueNativeDelegate (ChangeValue_cb);
				return ChangeValue_cb_delegate;
			}
		}

		static void OverrideChangeValue (GLib.GType gtype)
		{
			OverrideChangeValue (gtype, ChangeValueVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ChangeValueNativeDelegate (IntPtr inst, int scroll, double new_value);

		static bool ChangeValue_cb (IntPtr inst, int scroll, double new_value)
		{
			try {
				Range __obj = GLib.Object.GetObject (inst, false) as Range;
				bool __result;
				__result = __obj.OnChangeValue ((Gtk.ScrollType) scroll, new_value);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Range), ConnectionMethod="OverrideChangeValue")]
		protected virtual bool OnChangeValue (Gtk.ScrollType scroll, double new_value)
		{
			return InternalChangeValue (scroll, new_value);
		}

		private bool InternalChangeValue (Gtk.ScrollType scroll, double new_value)
		{
			ChangeValueNativeDelegate unmanaged = class_abi.BaseOverride<ChangeValueNativeDelegate>(this.LookupGType(), "change_value");
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, (int) scroll, new_value);
			return __result;
		}

		static GetRangeSizeRequestNativeDelegate GetRangeSizeRequest_cb_delegate;
		static GetRangeSizeRequestNativeDelegate GetRangeSizeRequestVMCallback {
			get {
				if (GetRangeSizeRequest_cb_delegate == null)
					GetRangeSizeRequest_cb_delegate = new GetRangeSizeRequestNativeDelegate (GetRangeSizeRequest_cb);
				return GetRangeSizeRequest_cb_delegate;
			}
		}

		static void OverrideGetRangeSizeRequest (GLib.GType gtype)
		{
			OverrideGetRangeSizeRequest (gtype, GetRangeSizeRequestVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetRangeSizeRequestNativeDelegate (IntPtr inst, int orientation, out int minimum, out int natural);

		static void GetRangeSizeRequest_cb (IntPtr inst, int orientation, out int minimum, out int natural)
		{
			try {
				Range __obj = GLib.Object.GetObject (inst, false) as Range;
				__obj.OnGetRangeSizeRequest ((Gtk.Orientation) orientation, out minimum, out natural);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Range), ConnectionMethod="OverrideGetRangeSizeRequest")]
		protected virtual void OnGetRangeSizeRequest (Gtk.Orientation orientation, out int minimum, out int natural)
		{
			InternalGetRangeSizeRequest (orientation, out minimum, out natural);
		}

		private void InternalGetRangeSizeRequest (Gtk.Orientation orientation, out int minimum, out int natural)
		{
			GetRangeSizeRequestNativeDelegate unmanaged = class_abi.BaseOverride<GetRangeSizeRequestNativeDelegate>(this.LookupGType(), "get_range_size_request");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, (int) orientation, out minimum, out natural);
		}


		// 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("slider_detail"
							, Gtk.Widget.class_abi.Fields
							, (uint) sizeof( IntPtr ) // slider_detail
							, null
							, "stepper_detail"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("stepper_detail"
							, -1
							, (uint) sizeof( IntPtr ) // stepper_detail
							, "slider_detail"
							, "value_changed"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("value_changed"
							, -1
							, (uint) sizeof( IntPtr ) // value_changed
							, "stepper_detail"
							, "adjust_bounds"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("adjust_bounds"
							, -1
							, (uint) sizeof( IntPtr ) // adjust_bounds
							, "value_changed"
							, "move_slider"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("move_slider"
							, -1
							, (uint) sizeof( IntPtr ) // move_slider
							, "adjust_bounds"
							, "get_range_border"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_range_border"
							, -1
							, (uint) sizeof( IntPtr ) // get_range_border
							, "move_slider"
							, "change_value"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("change_value"
							, -1
							, (uint) sizeof( IntPtr ) // change_value
							, "get_range_border"
							, "get_range_size_request"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_range_size_request"
							, -1
							, (uint) sizeof( IntPtr ) // get_range_size_request
							, "change_value"
							, "_gtk_reserved1"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved1
							, "get_range_size_request"
							, "_gtk_reserved2"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved2"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved2
							, "_gtk_reserved1"
							, "_gtk_reserved3"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved3"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved3
							, "_gtk_reserved2"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

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

		public bool Flippable { 
			get {
				bool raw_ret = gtk_range_get_flippable(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gtk_range_set_flippable(Handle, value);
			}
		}

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

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

		[Obsolete]
		public int MinSliderSize { 
			get {
				int raw_ret = gtk_range_get_min_slider_size(Handle);
				int ret = raw_ret;
				return ret;
			}
			set {
				gtk_range_set_min_slider_size(Handle, value);
			}
		}

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

		public void GetRangeRect(Gdk.Rectangle range_rect) {
			IntPtr native_range_rect = GLib.Marshaller.StructureToPtrAlloc (range_rect);
			gtk_range_get_range_rect(Handle, native_range_rect);
			Marshal.FreeHGlobal (native_range_rect);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_range_get_slider_range(IntPtr raw, out int slider_start, out int slider_end);
		static d_gtk_range_get_slider_range gtk_range_get_slider_range = FuncLoader.LoadFunction<d_gtk_range_get_slider_range>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_range_get_slider_range"));

		public void GetSliderRange(out int slider_start, out int slider_end) {
			gtk_range_get_slider_range(Handle, out slider_start, out slider_end);
		}

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

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

		public bool SliderSizeFixed { 
			get {
				bool raw_ret = gtk_range_get_slider_size_fixed(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gtk_range_set_slider_size_fixed(Handle, value);
			}
		}

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

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

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

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

		public double Value { 
			get {
				double raw_ret = gtk_range_get_value(Handle);
				double ret = raw_ret;
				return ret;
			}
			set {
				gtk_range_set_value(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_range_set_increments(IntPtr raw, double step, double page);
		static d_gtk_range_set_increments gtk_range_set_increments = FuncLoader.LoadFunction<d_gtk_range_set_increments>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_range_set_increments"));

		public void SetIncrements(double step, double page) {
			gtk_range_set_increments(Handle, step, page);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_range_set_range(IntPtr raw, double min, double max);
		static d_gtk_range_set_range gtk_range_set_range = FuncLoader.LoadFunction<d_gtk_range_set_range>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_range_set_range"));

		public void SetRange(double min, double max) {
			gtk_range_set_range(Handle, min, max);
		}


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

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}
