// 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;

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

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

		protected Range() : base(IntPtr.Zero)
		{
			CreateNativeObject (new string [0], new GLib.Value [0]);
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gtk_range_get_adjustment(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_adjustment(IntPtr raw, IntPtr 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);
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gtk_range_get_inverted(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_inverted(IntPtr raw, bool setting);

		[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);
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gtk_range_get_lower_stepper_sensitivity(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_lower_stepper_sensitivity(IntPtr raw, int 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);
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gtk_range_get_upper_stepper_sensitivity(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_upper_stepper_sensitivity(IntPtr raw, int 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);
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gtk_range_get_show_fill_level(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_show_fill_level(IntPtr raw, bool 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);
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gtk_range_get_restrict_to_fill_level(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_restrict_to_fill_level(IntPtr raw, bool 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);
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern double gtk_range_get_fill_level(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_fill_level(IntPtr raw, double 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);
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gtk_range_get_round_digits(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_round_digits(IntPtr raw, int 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);
			}
		}

		[GLib.Property ("slider-width")]
		public int SliderWidth {
			get {
				GLib.Value val = GetProperty ("slider-width");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("trough-border")]
		public int TroughBorder {
			get {
				GLib.Value val = GetProperty ("trough-border");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("stepper-size")]
		public int StepperSize {
			get {
				GLib.Value val = GetProperty ("stepper-size");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("stepper-spacing")]
		public int StepperSpacing {
			get {
				GLib.Value val = GetProperty ("stepper-spacing");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("arrow-displacement-x")]
		public int ArrowDisplacementX {
			get {
				GLib.Value val = GetProperty ("arrow-displacement-x");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("arrow-displacement-y")]
		public int ArrowDisplacementY {
			get {
				GLib.Value val = GetProperty ("arrow-displacement-y");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("trough-under-steppers")]
		public bool TroughUnderSteppers {
			get {
				GLib.Value val = GetProperty ("trough-under-steppers");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("arrow-scaling")]
		public float ArrowScaling {
			get {
				GLib.Value val = GetProperty ("arrow-scaling");
				float ret = (float) val;
				val.Dispose ();
				return ret;
			}
		}

		[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("change-value")]
		public event Gtk.ChangeValueHandler ChangeValue {
			add {
				this.AddSignalHandler ("change-value", value, typeof (Gtk.ChangeValueArgs));
			}
			remove {
				this.RemoveSignalHandler ("change-value", 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((Delegate) 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 = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("value_changed"));
				unmanaged = (ValueChangedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ValueChangedNativeDelegate));
			}
			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((Delegate) 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 = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_bounds"));
				unmanaged = (AdjustBoundsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AdjustBoundsNativeDelegate));
			}
			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((Delegate) 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 = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("move_slider"));
				unmanaged = (MoveSliderNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(MoveSliderNativeDelegate));
			}
			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((Delegate) 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 = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_range_border"));
				unmanaged = (GetRangeBorderNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetRangeBorderNativeDelegate));
			}
			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((Delegate) 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 e;
			}
		}

		[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 = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("change_value"));
				unmanaged = (ChangeValueNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ChangeValueNativeDelegate));
			}
			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((Delegate) 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 e;
			}
		}

		[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 = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_range_size_request"));
				unmanaged = (GetRangeSizeRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetRangeSizeRequestNativeDelegate));
			}
			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 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) Marshal.SizeOf(typeof(IntPtr)) // slider_detail
							, null
							, "stepper_detail"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("stepper_detail"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // stepper_detail
							, "slider_detail"
							, "value_changed"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("value_changed"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // value_changed
							, "stepper_detail"
							, "adjust_bounds"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("adjust_bounds"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // adjust_bounds
							, "value_changed"
							, "move_slider"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("move_slider"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // move_slider
							, "adjust_bounds"
							, "get_range_border"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_range_border"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_range_border
							, "move_slider"
							, "change_value"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("change_value"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // change_value
							, "get_range_border"
							, "get_range_size_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_range_size_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_range_size_request
							, "change_value"
							, "_gtk_reserved1"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // _gtk_reserved1
							, "get_range_size_request"
							, "_gtk_reserved2"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gtk_reserved2"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // _gtk_reserved2
							, "_gtk_reserved1"
							, "_gtk_reserved3"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gtk_reserved3"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // _gtk_reserved3
							, "_gtk_reserved2"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gtk_range_get_flippable(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_flippable(IntPtr raw, bool 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);
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gtk_range_get_min_slider_size(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_min_slider_size(IntPtr raw, int min_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);
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_get_range_rect(IntPtr raw, IntPtr 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);
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_get_slider_range(IntPtr raw, out int slider_start, out int slider_end);

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gtk_range_get_slider_size_fixed(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_slider_size_fixed(IntPtr raw, bool 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);
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr 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;
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern double gtk_range_get_value(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_value(IntPtr raw, double 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);
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_increments(IntPtr raw, double step, double page);

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_range_set_range(IntPtr raw, double min, double max);

		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 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) Marshal.SizeOf(typeof(IntPtr)) // priv
							, null
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}