------------------------------------------------------------------------------
-- --
-- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet --
-- Copyright (C) 2000-2014, AdaCore --
-- --
-- This library is free software; you can redistribute it and/or modify it --
-- under terms of the GNU General Public License as published by the Free --
-- Software Foundation; either version 3, or (at your option) any later --
-- version. This library is distributed in the hope that it will be useful, --
-- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- --
-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
------------------------------------------------------------------------------
-- <description>
-- Gtk.GRange.Gtk_Range is the common base class for widgets which visualize
-- an adjustment, e.g Gtk.Scale.Gtk_Scale or Gtk.Scrollbar.Gtk_Scrollbar.
--
-- Apart from signals for monitoring the parameters of the adjustment,
-- Gtk.GRange.Gtk_Range provides properties and methods for influencing the
-- sensitivity of the "steppers". It also provides properties and methods for
-- setting a "fill level" on range widgets. See Gtk.GRange.Set_Fill_Level.
--
-- </description>
-- <screenshot>gtk-range</screenshot>
-- <testgtk>create_range.adb</testgtk>
pragma Ada_2005;
pragma Warnings (Off, "*is already use-visible*");
with Gdk.Rectangle; use Gdk.Rectangle;
with Glib; use Glib;
with Glib.Object; use Glib.Object;
with Glib.Properties; use Glib.Properties;
with Glib.Types; use Glib.Types;
with Gtk.Adjustment; use Gtk.Adjustment;
with Gtk.Buildable; use Gtk.Buildable;
with Gtk.Enums; use Gtk.Enums;
with Gtk.Orientable; use Gtk.Orientable;
with Gtk.Widget; use Gtk.Widget;
package Gtk.GRange is
type Gtk_Range_Record is new Gtk_Widget_Record with null record;
type Gtk_Range is access all Gtk_Range_Record'Class;
------------------
-- Constructors --
------------------
function Get_Type return Glib.GType;
pragma Import (C, Get_Type, "gtk_range_get_type");
-------------
-- Methods --
-------------
function Get_Adjustment
(The_Range : not null access Gtk_Range_Record)
return Gtk.Adjustment.Gtk_Adjustment;
-- Get the Gtk.Adjustment.Gtk_Adjustment which is the "model" object for
-- Gtk.GRange.Gtk_Range. See Gtk.GRange.Set_Adjustment for details. The
-- return value does not have a reference added, so should not be
-- unreferenced.
procedure Set_Adjustment
(The_Range : not null access Gtk_Range_Record;
Adjustment : not null access Gtk.Adjustment.Gtk_Adjustment_Record'Class);
-- Sets the adjustment to be used as the "model" object for this range
-- widget. The adjustment indicates the current range value, the minimum
-- and maximum range values, the step/page increments used for keybindings
-- and scrolling, and the page size. The page size is normally 0 for
-- Gtk.Scale.Gtk_Scale and nonzero for Gtk.Scrollbar.Gtk_Scrollbar, and
-- indicates the size of the visible area of the widget being scrolled. The
-- page size affects the size of the scrollbar slider.
-- "adjustment": a Gtk.Adjustment.Gtk_Adjustment
function Get_Fill_Level
(The_Range : not null access Gtk_Range_Record) return Gdouble;
-- Gets the current position of the fill level indicator.
-- Since: gtk+ 2.12
procedure Set_Fill_Level
(The_Range : not null access Gtk_Range_Record;
Fill_Level : Gdouble);
-- Set the new position of the fill level indicator.
-- The "fill level" is probably best described by its most prominent use
-- case, which is an indicator for the amount of pre-buffering in a
-- streaming media player. In that use case, the value of the range would
-- indicate the current play position, and the fill level would be the
-- position up to which the file/stream has been downloaded.
-- This amount of prebuffering can be displayed on the range's trough and
-- is themeable separately from the trough. To enable fill level display,
-- use Gtk.GRange.Set_Show_Fill_Level. The range defaults to not showing
-- the fill level.
-- Additionally, it's possible to restrict the range's slider position to
-- values which are smaller than the fill level. This is controller by
-- Gtk.GRange.Set_Restrict_To_Fill_Level and is by default enabled.
-- Since: gtk+ 2.12
-- "fill_level": the new position of the fill level indicator
function Get_Flippable
(The_Range : not null access Gtk_Range_Record) return Boolean;
-- Gets the value set by Gtk.GRange.Set_Flippable.
-- Since: gtk+ 2.18
procedure Set_Flippable
(The_Range : not null access Gtk_Range_Record;
Flippable : Boolean);
-- If a range is flippable, it will switch its direction if it is
-- horizontal and its direction is Gtk.Enums.Text_Dir_Rtl.
-- See Gtk.Widget.Get_Direction.
-- Since: gtk+ 2.18
-- "flippable": True to make the range flippable
function Get_Inverted
(The_Range : not null access Gtk_Range_Record) return Boolean;
-- Gets the value set by Gtk.GRange.Set_Inverted.
procedure Set_Inverted
(The_Range : not null access Gtk_Range_Record;
Setting : Boolean);
-- Ranges normally move from lower to higher values as the slider moves
-- from top to bottom or left to right. Inverted ranges have higher values
-- at the top or on the right rather than on the bottom or left.
-- "setting": True to invert the range
function Get_Lower_Stepper_Sensitivity
(The_Range : not null access Gtk_Range_Record)
return Gtk.Enums.Gtk_Sensitivity_Type;
-- Gets the sensitivity policy for the stepper that points to the 'lower'
-- end of the GtkRange's adjustment.
-- Since: gtk+ 2.10
procedure Set_Lower_Stepper_Sensitivity
(The_Range : not null access Gtk_Range_Record;
Sensitivity : Gtk.Enums.Gtk_Sensitivity_Type);
-- Sets the sensitivity policy for the stepper that points to the 'lower'
-- end of the GtkRange's adjustment.
-- Since: gtk+ 2.10
-- "sensitivity": the lower stepper's sensitivity policy.
function Get_Min_Slider_Size
(The_Range : not null access Gtk_Range_Record) return Gint;
-- This function is useful mainly for Gtk.GRange.Gtk_Range subclasses.
-- See Gtk.GRange.Set_Min_Slider_Size.
-- Since: gtk+ 2.20
procedure Set_Min_Slider_Size
(The_Range : not null access Gtk_Range_Record;
Min_Size : Gint);
-- Sets the minimum size of the range's slider.
-- This function is useful mainly for Gtk.GRange.Gtk_Range subclasses.
-- Since: gtk+ 2.20
-- "min_size": The slider's minimum size
procedure Get_Range_Rect
(The_Range : not null access Gtk_Range_Record;
Range_Rect : out Gdk.Rectangle.Gdk_Rectangle);
-- This function returns the area that contains the range's trough and its
-- steppers, in widget->window coordinates.
-- This function is useful mainly for Gtk.GRange.Gtk_Range subclasses.
-- Since: gtk+ 2.20
-- "range_rect": return location for the range rectangle
function Get_Restrict_To_Fill_Level
(The_Range : not null access Gtk_Range_Record) return Boolean;
-- Gets whether the range is restricted to the fill level.
-- Since: gtk+ 2.12
procedure Set_Restrict_To_Fill_Level
(The_Range : not null access Gtk_Range_Record;
Restrict_To_Fill_Level : Boolean);
-- Sets whether the slider is restricted to the fill level. See
-- Gtk.GRange.Set_Fill_Level for a general description of the fill level
-- concept.
-- Since: gtk+ 2.12
-- "restrict_to_fill_level": Whether the fill level restricts slider
-- movement.
function Get_Round_Digits
(The_Range : not null access Gtk_Range_Record) return Gint;
-- Gets the number of digits to round the value to when it changes. See
-- Gtk.GRange.Gtk_Range::change-value.
-- Since: gtk+ 2.24
procedure Set_Round_Digits
(The_Range : not null access Gtk_Range_Record;
Round_Digits : Gint);
-- Sets the number of digits to round the value to when it changes. See
-- Gtk.GRange.Gtk_Range::change-value.
-- Since: gtk+ 2.24
-- "round_digits": the precision in digits, or -1
function Get_Show_Fill_Level
(The_Range : not null access Gtk_Range_Record) return Boolean;
-- Gets whether the range displays the fill level graphically.
-- Since: gtk+ 2.12
procedure Set_Show_Fill_Level
(The_Range : not null access Gtk_Range_Record;
Show_Fill_Level : Boolean);
-- Sets whether a graphical fill level is show on the trough. See
-- Gtk.GRange.Set_Fill_Level for a general description of the fill level
-- concept.
-- Since: gtk+ 2.12
-- "show_fill_level": Whether a fill level indicator graphics is shown.
procedure Get_Slider_Range
(The_Range : not null access Gtk_Range_Record;
Slider_Start : out Gint;
Slider_End : out Gint);
-- This function returns sliders range along the long dimension, in
-- widget->window coordinates.
-- This function is useful mainly for Gtk.GRange.Gtk_Range subclasses.
-- Since: gtk+ 2.20
-- "slider_start": return location for the slider's start, or null
-- "slider_end": return location for the slider's end, or null
function Get_Slider_Size_Fixed
(The_Range : not null access Gtk_Range_Record) return Boolean;
-- This function is useful mainly for Gtk.GRange.Gtk_Range subclasses.
-- See Gtk.GRange.Set_Slider_Size_Fixed.
-- Since: gtk+ 2.20
procedure Set_Slider_Size_Fixed
(The_Range : not null access Gtk_Range_Record;
Size_Fixed : Boolean);
-- Sets whether the range's slider has a fixed size, or a size that
-- depends on its adjustment's page size.
-- This function is useful mainly for Gtk.GRange.Gtk_Range subclasses.
-- Since: gtk+ 2.20
-- "size_fixed": True to make the slider size constant
function Get_Upper_Stepper_Sensitivity
(The_Range : not null access Gtk_Range_Record)
return Gtk.Enums.Gtk_Sensitivity_Type;
-- Gets the sensitivity policy for the stepper that points to the 'upper'
-- end of the GtkRange's adjustment.
-- Since: gtk+ 2.10
procedure Set_Upper_Stepper_Sensitivity
(The_Range : not null access Gtk_Range_Record;
Sensitivity : Gtk.Enums.Gtk_Sensitivity_Type);
-- Sets the sensitivity policy for the stepper that points to the 'upper'
-- end of the GtkRange's adjustment.
-- Since: gtk+ 2.10
-- "sensitivity": the upper stepper's sensitivity policy.
function Get_Value
(The_Range : not null access Gtk_Range_Record) return Gdouble;
-- Gets the current value of the range.
procedure Set_Value
(The_Range : not null access Gtk_Range_Record;
Value : Gdouble);
-- Sets the current value of the range; if the value is outside the
-- minimum or maximum range values, it will be clamped to fit inside them.
-- The range emits the Gtk.GRange.Gtk_Range::value-changed signal if the
-- value changes.
-- "value": new value of the range
procedure Set_Increments
(The_Range : not null access Gtk_Range_Record;
Step : Gdouble;
Page : Gdouble);
-- Sets the step and page sizes for the range. The step size is used when
-- the user clicks the Gtk.Scrollbar.Gtk_Scrollbar arrows or moves
-- Gtk.Scale.Gtk_Scale via arrow keys. The page size is used for example
-- when moving via Page Up or Page Down keys.
-- "step": step size
-- "page": page size
procedure Set_Range
(The_Range : not null access Gtk_Range_Record;
Min : Gdouble;
Max : Gdouble);
-- Sets the allowable values in the Gtk.GRange.Gtk_Range, and clamps the
-- range value to be between Min and Max. (If the range has a non-zero page
-- size, it is clamped between Min and Max - page-size.)
-- "min": minimum range value
-- "max": maximum range value
---------------------------------------------
-- Inherited subprograms (from interfaces) --
---------------------------------------------
-- Methods inherited from the Buildable interface are not duplicated here
-- since they are meant to be used by tools, mostly. If you need to call
-- them, use an explicit cast through the "-" operator below.
function Get_Orientation
(Self : not null access Gtk_Range_Record)
return Gtk.Enums.Gtk_Orientation;
procedure Set_Orientation
(Self : not null access Gtk_Range_Record;
Orientation : Gtk.Enums.Gtk_Orientation);
----------------
-- Properties --
----------------
-- The following properties are defined for this widget. See
-- Glib.Properties for more information on properties)
Adjustment_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Adjustment.Gtk_Adjustment
Fill_Level_Property : constant Glib.Properties.Property_Double;
-- Type: Gdouble
-- The fill level (e.g. prebuffering of a network stream). See
-- Gtk.GRange.Set_Fill_Level.
Inverted_Property : constant Glib.Properties.Property_Boolean;
Lower_Stepper_Sensitivity_Property : constant Gtk.Enums.Property_Gtk_Sensitivity_Type;
Restrict_To_Fill_Level_Property : constant Glib.Properties.Property_Boolean;
-- The restrict-to-fill-level property controls whether slider movement is
-- restricted to an upper boundary set by the fill level. See
-- Gtk.GRange.Set_Restrict_To_Fill_Level.
Round_Digits_Property : constant Glib.Properties.Property_Int;
-- The number of digits to round the value to when it changes, or -1. See
-- Gtk.GRange.Gtk_Range::change-value.
Show_Fill_Level_Property : constant Glib.Properties.Property_Boolean;
-- The show-fill-level property controls whether fill level indicator
-- graphics are displayed on the trough. See
-- Gtk.GRange.Set_Show_Fill_Level.
Upper_Stepper_Sensitivity_Property : constant Gtk.Enums.Property_Gtk_Sensitivity_Type;
-------------
-- Signals --
-------------
type Cb_Gtk_Range_Gdouble_Void is not null access procedure
(Self : access Gtk_Range_Record'Class;
Value : Gdouble);
type Cb_GObject_Gdouble_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Value : Gdouble);
Signal_Adjust_Bounds : constant Glib.Signal_Name := "adjust-bounds";
procedure On_Adjust_Bounds
(Self : not null access Gtk_Range_Record;
Call : Cb_Gtk_Range_Gdouble_Void;
After : Boolean := False);
procedure On_Adjust_Bounds
(Self : not null access Gtk_Range_Record;
Call : Cb_GObject_Gdouble_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- Emitted before clamping a value, to give the application a chance to
-- adjust the bounds.
type Cb_Gtk_Range_Gtk_Scroll_Type_Gdouble_Boolean is not null access function
(Self : access Gtk_Range_Record'Class;
Scroll : Gtk.Enums.Gtk_Scroll_Type;
Value : Gdouble) return Boolean;
type Cb_GObject_Gtk_Scroll_Type_Gdouble_Boolean is not null access function
(Self : access Glib.Object.GObject_Record'Class;
Scroll : Gtk.Enums.Gtk_Scroll_Type;
Value : Gdouble) return Boolean;
Signal_Change_Value : constant Glib.Signal_Name := "change-value";
procedure On_Change_Value
(Self : not null access Gtk_Range_Record;
Call : Cb_Gtk_Range_Gtk_Scroll_Type_Gdouble_Boolean;
After : Boolean := False);
procedure On_Change_Value
(Self : not null access Gtk_Range_Record;
Call : Cb_GObject_Gtk_Scroll_Type_Gdouble_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The Gtk.GRange.Gtk_Range::change-value signal is emitted when a scroll
-- action is performed on a range. It allows an application to determine
-- the type of scroll event that occurred and the resultant new value. The
-- application can handle the event itself and return True to prevent
-- further processing. Or, by returning False, it can pass the event to
-- other handlers until the default GTK+ handler is reached.
--
-- The value parameter is unrounded. An application that overrides the
-- GtkRange::change-value signal is responsible for clamping the value to
-- the desired number of decimal digits; the default GTK+ handler clamps
-- the value based on Gtk.GRange.Gtk_Range:round-digits.
--
-- It is not possible to use delayed update policies in an overridden
-- Gtk.GRange.Gtk_Range::change-value handler.
--
-- Callback parameters:
-- -- "scroll": the type of scroll action that was performed
-- -- "value": the new value resulting from the scroll action
-- -- Returns True to prevent other handlers from being invoked for the signal, False to propagate the signal further
type Cb_Gtk_Range_Gtk_Scroll_Type_Void is not null access procedure
(Self : access Gtk_Range_Record'Class;
Step : Gtk.Enums.Gtk_Scroll_Type);
type Cb_GObject_Gtk_Scroll_Type_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Step : Gtk.Enums.Gtk_Scroll_Type);
Signal_Move_Slider : constant Glib.Signal_Name := "move-slider";
procedure On_Move_Slider
(Self : not null access Gtk_Range_Record;
Call : Cb_Gtk_Range_Gtk_Scroll_Type_Void;
After : Boolean := False);
procedure On_Move_Slider
(Self : not null access Gtk_Range_Record;
Call : Cb_GObject_Gtk_Scroll_Type_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- Virtual function that moves the slider. Used for keybindings.
type Cb_Gtk_Range_Void is not null access procedure (Self : access Gtk_Range_Record'Class);
type Cb_GObject_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class);
Signal_Value_Changed : constant Glib.Signal_Name := "value-changed";
procedure On_Value_Changed
(Self : not null access Gtk_Range_Record;
Call : Cb_Gtk_Range_Void;
After : Boolean := False);
procedure On_Value_Changed
(Self : not null access Gtk_Range_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- Emitted when the range value changes.
----------------
-- Interfaces --
----------------
-- This class implements several interfaces. See Glib.Types
--
-- - "Buildable"
--
-- - "Orientable"
package Implements_Gtk_Buildable is new Glib.Types.Implements
(Gtk.Buildable.Gtk_Buildable, Gtk_Range_Record, Gtk_Range);
function "+"
(Widget : access Gtk_Range_Record'Class)
return Gtk.Buildable.Gtk_Buildable
renames Implements_Gtk_Buildable.To_Interface;
function "-"
(Interf : Gtk.Buildable.Gtk_Buildable)
return Gtk_Range
renames Implements_Gtk_Buildable.To_Object;
package Implements_Gtk_Orientable is new Glib.Types.Implements
(Gtk.Orientable.Gtk_Orientable, Gtk_Range_Record, Gtk_Range);
function "+"
(Widget : access Gtk_Range_Record'Class)
return Gtk.Orientable.Gtk_Orientable
renames Implements_Gtk_Orientable.To_Interface;
function "-"
(Interf : Gtk.Orientable.Gtk_Orientable)
return Gtk_Range
renames Implements_Gtk_Orientable.To_Object;
private
Upper_Stepper_Sensitivity_Property : constant Gtk.Enums.Property_Gtk_Sensitivity_Type :=
Gtk.Enums.Build ("upper-stepper-sensitivity");
Show_Fill_Level_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("show-fill-level");
Round_Digits_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("round-digits");
Restrict_To_Fill_Level_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("restrict-to-fill-level");
Lower_Stepper_Sensitivity_Property : constant Gtk.Enums.Property_Gtk_Sensitivity_Type :=
Gtk.Enums.Build ("lower-stepper-sensitivity");
Inverted_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("inverted");
Fill_Level_Property : constant Glib.Properties.Property_Double :=
Glib.Properties.Build ("fill-level");
Adjustment_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("adjustment");
end Gtk.GRange;