1. ------------------------------------------------------------------------------ 
  2. --                                                                          -- 
  3. --      Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet       -- 
  4. --                     Copyright (C) 2000-2014, AdaCore                     -- 
  5. --                                                                          -- 
  6. -- This library is free software;  you can redistribute it and/or modify it -- 
  7. -- under terms of the  GNU General Public License  as published by the Free -- 
  8. -- Software  Foundation;  either version 3,  or (at your  option) any later -- 
  9. -- version. This library is distributed in the hope that it will be useful, -- 
  10. -- but WITHOUT ANY WARRANTY;  without even the implied warranty of MERCHAN- -- 
  11. -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE.                            -- 
  12. --                                                                          -- 
  13. -- As a special exception under Section 7 of GPL version 3, you are granted -- 
  14. -- additional permissions described in the GCC Runtime Library Exception,   -- 
  15. -- version 3.1, as published by the Free Software Foundation.               -- 
  16. --                                                                          -- 
  17. -- You should have received a copy of the GNU General Public License and    -- 
  18. -- a copy of the GCC Runtime Library Exception along with this program;     -- 
  19. -- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    -- 
  20. -- <http://www.gnu.org/licenses/>.                                          -- 
  21. --                                                                          -- 
  22. ------------------------------------------------------------------------------ 
  23.  
  24. --  <description> 
  25. --  Gtk.GRange.Gtk_Range is the common base class for widgets which visualize 
  26. --  an adjustment, e.g Gtk.Scale.Gtk_Scale or Gtk.Scrollbar.Gtk_Scrollbar. 
  27. -- 
  28. --  Apart from signals for monitoring the parameters of the adjustment, 
  29. --  Gtk.GRange.Gtk_Range provides properties and methods for influencing the 
  30. --  sensitivity of the "steppers". It also provides properties and methods for 
  31. --  setting a "fill level" on range widgets. See Gtk.GRange.Set_Fill_Level. 
  32. -- 
  33. --  </description> 
  34. --  <screenshot>gtk-range</screenshot> 
  35. --  <testgtk>create_range.adb</testgtk> 
  36. pragma Ada_2005; 
  37.  
  38. pragma Warnings (Off, "*is already use-visible*"); 
  39. with Gdk.Rectangle;   use Gdk.Rectangle; 
  40. with Glib;            use Glib; 
  41. with Glib.Object;     use Glib.Object; 
  42. with Glib.Properties; use Glib.Properties; 
  43. with Glib.Types;      use Glib.Types; 
  44. with Gtk.Adjustment;  use Gtk.Adjustment; 
  45. with Gtk.Buildable;   use Gtk.Buildable; 
  46. with Gtk.Enums;       use Gtk.Enums; 
  47. with Gtk.Orientable;  use Gtk.Orientable; 
  48. with Gtk.Widget;      use Gtk.Widget; 
  49.  
  50. package Gtk.GRange is 
  51.  
  52.    type Gtk_Range_Record is new Gtk_Widget_Record with null record; 
  53.    type Gtk_Range is access all Gtk_Range_Record'Class; 
  54.  
  55.    ------------------ 
  56.    -- Constructors -- 
  57.    ------------------ 
  58.  
  59.    function Get_Type return Glib.GType; 
  60.    pragma Import (C, Get_Type, "gtk_range_get_type"); 
  61.  
  62.    ------------- 
  63.    -- Methods -- 
  64.    ------------- 
  65.  
  66.    function Get_Adjustment 
  67.       (The_Range : not null access Gtk_Range_Record) 
  68.        return Gtk.Adjustment.Gtk_Adjustment; 
  69.    --  Get the Gtk.Adjustment.Gtk_Adjustment which is the "model" object for 
  70.    --  Gtk.GRange.Gtk_Range. See Gtk.GRange.Set_Adjustment for details. The 
  71.    --  return value does not have a reference added, so should not be 
  72.    --  unreferenced. 
  73.  
  74.    procedure Set_Adjustment 
  75.       (The_Range  : not null access Gtk_Range_Record; 
  76.        Adjustment : not null access Gtk.Adjustment.Gtk_Adjustment_Record'Class); 
  77.    --  Sets the adjustment to be used as the "model" object for this range 
  78.    --  widget. The adjustment indicates the current range value, the minimum 
  79.    --  and maximum range values, the step/page increments used for keybindings 
  80.    --  and scrolling, and the page size. The page size is normally 0 for 
  81.    --  Gtk.Scale.Gtk_Scale and nonzero for Gtk.Scrollbar.Gtk_Scrollbar, and 
  82.    --  indicates the size of the visible area of the widget being scrolled. The 
  83.    --  page size affects the size of the scrollbar slider. 
  84.    --  "adjustment": a Gtk.Adjustment.Gtk_Adjustment 
  85.  
  86.    function Get_Fill_Level 
  87.       (The_Range : not null access Gtk_Range_Record) return Gdouble; 
  88.    --  Gets the current position of the fill level indicator. 
  89.    --  Since: gtk+ 2.12 
  90.  
  91.    procedure Set_Fill_Level 
  92.       (The_Range  : not null access Gtk_Range_Record; 
  93.        Fill_Level : Gdouble); 
  94.    --  Set the new position of the fill level indicator. 
  95.    --  The "fill level" is probably best described by its most prominent use 
  96.    --  case, which is an indicator for the amount of pre-buffering in a 
  97.    --  streaming media player. In that use case, the value of the range would 
  98.    --  indicate the current play position, and the fill level would be the 
  99.    --  position up to which the file/stream has been downloaded. 
  100.    --  This amount of prebuffering can be displayed on the range's trough and 
  101.    --  is themeable separately from the trough. To enable fill level display, 
  102.    --  use Gtk.GRange.Set_Show_Fill_Level. The range defaults to not showing 
  103.    --  the fill level. 
  104.    --  Additionally, it's possible to restrict the range's slider position to 
  105.    --  values which are smaller than the fill level. This is controller by 
  106.    --  Gtk.GRange.Set_Restrict_To_Fill_Level and is by default enabled. 
  107.    --  Since: gtk+ 2.12 
  108.    --  "fill_level": the new position of the fill level indicator 
  109.  
  110.    function Get_Flippable 
  111.       (The_Range : not null access Gtk_Range_Record) return Boolean; 
  112.    --  Gets the value set by Gtk.GRange.Set_Flippable. 
  113.    --  Since: gtk+ 2.18 
  114.  
  115.    procedure Set_Flippable 
  116.       (The_Range : not null access Gtk_Range_Record; 
  117.        Flippable : Boolean); 
  118.    --  If a range is flippable, it will switch its direction if it is 
  119.    --  horizontal and its direction is Gtk.Enums.Text_Dir_Rtl. 
  120.    --  See Gtk.Widget.Get_Direction. 
  121.    --  Since: gtk+ 2.18 
  122.    --  "flippable": True to make the range flippable 
  123.  
  124.    function Get_Inverted 
  125.       (The_Range : not null access Gtk_Range_Record) return Boolean; 
  126.    --  Gets the value set by Gtk.GRange.Set_Inverted. 
  127.  
  128.    procedure Set_Inverted 
  129.       (The_Range : not null access Gtk_Range_Record; 
  130.        Setting   : Boolean); 
  131.    --  Ranges normally move from lower to higher values as the slider moves 
  132.    --  from top to bottom or left to right. Inverted ranges have higher values 
  133.    --  at the top or on the right rather than on the bottom or left. 
  134.    --  "setting": True to invert the range 
  135.  
  136.    function Get_Lower_Stepper_Sensitivity 
  137.       (The_Range : not null access Gtk_Range_Record) 
  138.        return Gtk.Enums.Gtk_Sensitivity_Type; 
  139.    --  Gets the sensitivity policy for the stepper that points to the 'lower' 
  140.    --  end of the GtkRange's adjustment. 
  141.    --  Since: gtk+ 2.10 
  142.  
  143.    procedure Set_Lower_Stepper_Sensitivity 
  144.       (The_Range   : not null access Gtk_Range_Record; 
  145.        Sensitivity : Gtk.Enums.Gtk_Sensitivity_Type); 
  146.    --  Sets the sensitivity policy for the stepper that points to the 'lower' 
  147.    --  end of the GtkRange's adjustment. 
  148.    --  Since: gtk+ 2.10 
  149.    --  "sensitivity": the lower stepper's sensitivity policy. 
  150.  
  151.    function Get_Min_Slider_Size 
  152.       (The_Range : not null access Gtk_Range_Record) return Gint; 
  153.    --  This function is useful mainly for Gtk.GRange.Gtk_Range subclasses. 
  154.    --  See Gtk.GRange.Set_Min_Slider_Size. 
  155.    --  Since: gtk+ 2.20 
  156.  
  157.    procedure Set_Min_Slider_Size 
  158.       (The_Range : not null access Gtk_Range_Record; 
  159.        Min_Size  : Gint); 
  160.    --  Sets the minimum size of the range's slider. 
  161.    --  This function is useful mainly for Gtk.GRange.Gtk_Range subclasses. 
  162.    --  Since: gtk+ 2.20 
  163.    --  "min_size": The slider's minimum size 
  164.  
  165.    procedure Get_Range_Rect 
  166.       (The_Range  : not null access Gtk_Range_Record; 
  167.        Range_Rect : out Gdk.Rectangle.Gdk_Rectangle); 
  168.    --  This function returns the area that contains the range's trough and its 
  169.    --  steppers, in widget->window coordinates. 
  170.    --  This function is useful mainly for Gtk.GRange.Gtk_Range subclasses. 
  171.    --  Since: gtk+ 2.20 
  172.    --  "range_rect": return location for the range rectangle 
  173.  
  174.    function Get_Restrict_To_Fill_Level 
  175.       (The_Range : not null access Gtk_Range_Record) return Boolean; 
  176.    --  Gets whether the range is restricted to the fill level. 
  177.    --  Since: gtk+ 2.12 
  178.  
  179.    procedure Set_Restrict_To_Fill_Level 
  180.       (The_Range              : not null access Gtk_Range_Record; 
  181.        Restrict_To_Fill_Level : Boolean); 
  182.    --  Sets whether the slider is restricted to the fill level. See 
  183.    --  Gtk.GRange.Set_Fill_Level for a general description of the fill level 
  184.    --  concept. 
  185.    --  Since: gtk+ 2.12 
  186.    --  "restrict_to_fill_level": Whether the fill level restricts slider 
  187.    --  movement. 
  188.  
  189.    function Get_Round_Digits 
  190.       (The_Range : not null access Gtk_Range_Record) return Gint; 
  191.    --  Gets the number of digits to round the value to when it changes. See 
  192.    --  Gtk.GRange.Gtk_Range::change-value. 
  193.    --  Since: gtk+ 2.24 
  194.  
  195.    procedure Set_Round_Digits 
  196.       (The_Range    : not null access Gtk_Range_Record; 
  197.        Round_Digits : Gint); 
  198.    --  Sets the number of digits to round the value to when it changes. See 
  199.    --  Gtk.GRange.Gtk_Range::change-value. 
  200.    --  Since: gtk+ 2.24 
  201.    --  "round_digits": the precision in digits, or -1 
  202.  
  203.    function Get_Show_Fill_Level 
  204.       (The_Range : not null access Gtk_Range_Record) return Boolean; 
  205.    --  Gets whether the range displays the fill level graphically. 
  206.    --  Since: gtk+ 2.12 
  207.  
  208.    procedure Set_Show_Fill_Level 
  209.       (The_Range       : not null access Gtk_Range_Record; 
  210.        Show_Fill_Level : Boolean); 
  211.    --  Sets whether a graphical fill level is show on the trough. See 
  212.    --  Gtk.GRange.Set_Fill_Level for a general description of the fill level 
  213.    --  concept. 
  214.    --  Since: gtk+ 2.12 
  215.    --  "show_fill_level": Whether a fill level indicator graphics is shown. 
  216.  
  217.    procedure Get_Slider_Range 
  218.       (The_Range    : not null access Gtk_Range_Record; 
  219.        Slider_Start : out Gint; 
  220.        Slider_End   : out Gint); 
  221.    --  This function returns sliders range along the long dimension, in 
  222.    --  widget->window coordinates. 
  223.    --  This function is useful mainly for Gtk.GRange.Gtk_Range subclasses. 
  224.    --  Since: gtk+ 2.20 
  225.    --  "slider_start": return location for the slider's start, or null 
  226.    --  "slider_end": return location for the slider's end, or null 
  227.  
  228.    function Get_Slider_Size_Fixed 
  229.       (The_Range : not null access Gtk_Range_Record) return Boolean; 
  230.    --  This function is useful mainly for Gtk.GRange.Gtk_Range subclasses. 
  231.    --  See Gtk.GRange.Set_Slider_Size_Fixed. 
  232.    --  Since: gtk+ 2.20 
  233.  
  234.    procedure Set_Slider_Size_Fixed 
  235.       (The_Range  : not null access Gtk_Range_Record; 
  236.        Size_Fixed : Boolean); 
  237.    --  Sets whether the range's slider has a fixed size, or a size that 
  238.    --  depends on its adjustment's page size. 
  239.    --  This function is useful mainly for Gtk.GRange.Gtk_Range subclasses. 
  240.    --  Since: gtk+ 2.20 
  241.    --  "size_fixed": True to make the slider size constant 
  242.  
  243.    function Get_Upper_Stepper_Sensitivity 
  244.       (The_Range : not null access Gtk_Range_Record) 
  245.        return Gtk.Enums.Gtk_Sensitivity_Type; 
  246.    --  Gets the sensitivity policy for the stepper that points to the 'upper' 
  247.    --  end of the GtkRange's adjustment. 
  248.    --  Since: gtk+ 2.10 
  249.  
  250.    procedure Set_Upper_Stepper_Sensitivity 
  251.       (The_Range   : not null access Gtk_Range_Record; 
  252.        Sensitivity : Gtk.Enums.Gtk_Sensitivity_Type); 
  253.    --  Sets the sensitivity policy for the stepper that points to the 'upper' 
  254.    --  end of the GtkRange's adjustment. 
  255.    --  Since: gtk+ 2.10 
  256.    --  "sensitivity": the upper stepper's sensitivity policy. 
  257.  
  258.    function Get_Value 
  259.       (The_Range : not null access Gtk_Range_Record) return Gdouble; 
  260.    --  Gets the current value of the range. 
  261.  
  262.    procedure Set_Value 
  263.       (The_Range : not null access Gtk_Range_Record; 
  264.        Value     : Gdouble); 
  265.    --  Sets the current value of the range; if the value is outside the 
  266.    --  minimum or maximum range values, it will be clamped to fit inside them. 
  267.    --  The range emits the Gtk.GRange.Gtk_Range::value-changed signal if the 
  268.    --  value changes. 
  269.    --  "value": new value of the range 
  270.  
  271.    procedure Set_Increments 
  272.       (The_Range : not null access Gtk_Range_Record; 
  273.        Step      : Gdouble; 
  274.        Page      : Gdouble); 
  275.    --  Sets the step and page sizes for the range. The step size is used when 
  276.    --  the user clicks the Gtk.Scrollbar.Gtk_Scrollbar arrows or moves 
  277.    --  Gtk.Scale.Gtk_Scale via arrow keys. The page size is used for example 
  278.    --  when moving via Page Up or Page Down keys. 
  279.    --  "step": step size 
  280.    --  "page": page size 
  281.  
  282.    procedure Set_Range 
  283.       (The_Range : not null access Gtk_Range_Record; 
  284.        Min       : Gdouble; 
  285.        Max       : Gdouble); 
  286.    --  Sets the allowable values in the Gtk.GRange.Gtk_Range, and clamps the 
  287.    --  range value to be between Min and Max. (If the range has a non-zero page 
  288.    --  size, it is clamped between Min and Max - page-size.) 
  289.    --  "min": minimum range value 
  290.    --  "max": maximum range value 
  291.  
  292.    --------------------------------------------- 
  293.    -- Inherited subprograms (from interfaces) -- 
  294.    --------------------------------------------- 
  295.    --  Methods inherited from the Buildable interface are not duplicated here 
  296.    --  since they are meant to be used by tools, mostly. If you need to call 
  297.    --  them, use an explicit cast through the "-" operator below. 
  298.  
  299.    function Get_Orientation 
  300.       (Self : not null access Gtk_Range_Record) 
  301.        return Gtk.Enums.Gtk_Orientation; 
  302.  
  303.    procedure Set_Orientation 
  304.       (Self        : not null access Gtk_Range_Record; 
  305.        Orientation : Gtk.Enums.Gtk_Orientation); 
  306.  
  307.    ---------------- 
  308.    -- Properties -- 
  309.    ---------------- 
  310.    --  The following properties are defined for this widget. See 
  311.    --  Glib.Properties for more information on properties) 
  312.  
  313.    Adjustment_Property : constant Glib.Properties.Property_Object; 
  314.    --  Type: Gtk.Adjustment.Gtk_Adjustment 
  315.  
  316.    Fill_Level_Property : constant Glib.Properties.Property_Double; 
  317.    --  Type: Gdouble 
  318.    --  The fill level (e.g. prebuffering of a network stream). See 
  319.    --  Gtk.GRange.Set_Fill_Level. 
  320.  
  321.    Inverted_Property : constant Glib.Properties.Property_Boolean; 
  322.  
  323.    Lower_Stepper_Sensitivity_Property : constant Gtk.Enums.Property_Gtk_Sensitivity_Type; 
  324.  
  325.    Restrict_To_Fill_Level_Property : constant Glib.Properties.Property_Boolean; 
  326.    --  The restrict-to-fill-level property controls whether slider movement is 
  327.    --  restricted to an upper boundary set by the fill level. See 
  328.    --  Gtk.GRange.Set_Restrict_To_Fill_Level. 
  329.  
  330.    Round_Digits_Property : constant Glib.Properties.Property_Int; 
  331.    --  The number of digits to round the value to when it changes, or -1. See 
  332.    --  Gtk.GRange.Gtk_Range::change-value. 
  333.  
  334.    Show_Fill_Level_Property : constant Glib.Properties.Property_Boolean; 
  335.    --  The show-fill-level property controls whether fill level indicator 
  336.    --  graphics are displayed on the trough. See 
  337.    --  Gtk.GRange.Set_Show_Fill_Level. 
  338.  
  339.    Upper_Stepper_Sensitivity_Property : constant Gtk.Enums.Property_Gtk_Sensitivity_Type; 
  340.  
  341.    ------------- 
  342.    -- Signals -- 
  343.    ------------- 
  344.  
  345.    type Cb_Gtk_Range_Gdouble_Void is not null access procedure 
  346.      (Self  : access Gtk_Range_Record'Class; 
  347.       Value : Gdouble); 
  348.  
  349.    type Cb_GObject_Gdouble_Void is not null access procedure 
  350.      (Self  : access Glib.Object.GObject_Record'Class; 
  351.       Value : Gdouble); 
  352.  
  353.    Signal_Adjust_Bounds : constant Glib.Signal_Name := "adjust-bounds"; 
  354.    procedure On_Adjust_Bounds 
  355.       (Self  : not null access Gtk_Range_Record; 
  356.        Call  : Cb_Gtk_Range_Gdouble_Void; 
  357.        After : Boolean := False); 
  358.    procedure On_Adjust_Bounds 
  359.       (Self  : not null access Gtk_Range_Record; 
  360.        Call  : Cb_GObject_Gdouble_Void; 
  361.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  362.        After : Boolean := False); 
  363.    --  Emitted before clamping a value, to give the application a chance to 
  364.    --  adjust the bounds. 
  365.  
  366.    type Cb_Gtk_Range_Gtk_Scroll_Type_Gdouble_Boolean is not null access function 
  367.      (Self   : access Gtk_Range_Record'Class; 
  368.       Scroll : Gtk.Enums.Gtk_Scroll_Type; 
  369.       Value  : Gdouble) return Boolean; 
  370.  
  371.    type Cb_GObject_Gtk_Scroll_Type_Gdouble_Boolean is not null access function 
  372.      (Self   : access Glib.Object.GObject_Record'Class; 
  373.       Scroll : Gtk.Enums.Gtk_Scroll_Type; 
  374.       Value  : Gdouble) return Boolean; 
  375.  
  376.    Signal_Change_Value : constant Glib.Signal_Name := "change-value"; 
  377.    procedure On_Change_Value 
  378.       (Self  : not null access Gtk_Range_Record; 
  379.        Call  : Cb_Gtk_Range_Gtk_Scroll_Type_Gdouble_Boolean; 
  380.        After : Boolean := False); 
  381.    procedure On_Change_Value 
  382.       (Self  : not null access Gtk_Range_Record; 
  383.        Call  : Cb_GObject_Gtk_Scroll_Type_Gdouble_Boolean; 
  384.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  385.        After : Boolean := False); 
  386.    --  The Gtk.GRange.Gtk_Range::change-value signal is emitted when a scroll 
  387.    --  action is performed on a range. It allows an application to determine 
  388.    --  the type of scroll event that occurred and the resultant new value. The 
  389.    --  application can handle the event itself and return True to prevent 
  390.    --  further processing. Or, by returning False, it can pass the event to 
  391.    --  other handlers until the default GTK+ handler is reached. 
  392.    -- 
  393.    --  The value parameter is unrounded. An application that overrides the 
  394.    --  GtkRange::change-value signal is responsible for clamping the value to 
  395.    --  the desired number of decimal digits; the default GTK+ handler clamps 
  396.    --  the value based on Gtk.GRange.Gtk_Range:round-digits. 
  397.    -- 
  398.    --  It is not possible to use delayed update policies in an overridden 
  399.    --  Gtk.GRange.Gtk_Range::change-value handler. 
  400.    --  
  401.    --  Callback parameters: 
  402.    --    --  "scroll": the type of scroll action that was performed 
  403.    --    --  "value": the new value resulting from the scroll action 
  404.    --    --  Returns True to prevent other handlers from being invoked for the signal, False to propagate the signal further 
  405.  
  406.    type Cb_Gtk_Range_Gtk_Scroll_Type_Void is not null access procedure 
  407.      (Self : access Gtk_Range_Record'Class; 
  408.       Step : Gtk.Enums.Gtk_Scroll_Type); 
  409.  
  410.    type Cb_GObject_Gtk_Scroll_Type_Void is not null access procedure 
  411.      (Self : access Glib.Object.GObject_Record'Class; 
  412.       Step : Gtk.Enums.Gtk_Scroll_Type); 
  413.  
  414.    Signal_Move_Slider : constant Glib.Signal_Name := "move-slider"; 
  415.    procedure On_Move_Slider 
  416.       (Self  : not null access Gtk_Range_Record; 
  417.        Call  : Cb_Gtk_Range_Gtk_Scroll_Type_Void; 
  418.        After : Boolean := False); 
  419.    procedure On_Move_Slider 
  420.       (Self  : not null access Gtk_Range_Record; 
  421.        Call  : Cb_GObject_Gtk_Scroll_Type_Void; 
  422.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  423.        After : Boolean := False); 
  424.    --  Virtual function that moves the slider. Used for keybindings. 
  425.  
  426.    type Cb_Gtk_Range_Void is not null access procedure (Self : access Gtk_Range_Record'Class); 
  427.  
  428.    type Cb_GObject_Void is not null access procedure 
  429.      (Self : access Glib.Object.GObject_Record'Class); 
  430.  
  431.    Signal_Value_Changed : constant Glib.Signal_Name := "value-changed"; 
  432.    procedure On_Value_Changed 
  433.       (Self  : not null access Gtk_Range_Record; 
  434.        Call  : Cb_Gtk_Range_Void; 
  435.        After : Boolean := False); 
  436.    procedure On_Value_Changed 
  437.       (Self  : not null access Gtk_Range_Record; 
  438.        Call  : Cb_GObject_Void; 
  439.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  440.        After : Boolean := False); 
  441.    --  Emitted when the range value changes. 
  442.  
  443.    ---------------- 
  444.    -- Interfaces -- 
  445.    ---------------- 
  446.    --  This class implements several interfaces. See Glib.Types 
  447.    -- 
  448.    --  - "Buildable" 
  449.    -- 
  450.    --  - "Orientable" 
  451.  
  452.    package Implements_Gtk_Buildable is new Glib.Types.Implements 
  453.      (Gtk.Buildable.Gtk_Buildable, Gtk_Range_Record, Gtk_Range); 
  454.    function "+" 
  455.      (Widget : access Gtk_Range_Record'Class) 
  456.    return Gtk.Buildable.Gtk_Buildable 
  457.    renames Implements_Gtk_Buildable.To_Interface; 
  458.    function "-" 
  459.      (Interf : Gtk.Buildable.Gtk_Buildable) 
  460.    return Gtk_Range 
  461.    renames Implements_Gtk_Buildable.To_Object; 
  462.  
  463.    package Implements_Gtk_Orientable is new Glib.Types.Implements 
  464.      (Gtk.Orientable.Gtk_Orientable, Gtk_Range_Record, Gtk_Range); 
  465.    function "+" 
  466.      (Widget : access Gtk_Range_Record'Class) 
  467.    return Gtk.Orientable.Gtk_Orientable 
  468.    renames Implements_Gtk_Orientable.To_Interface; 
  469.    function "-" 
  470.      (Interf : Gtk.Orientable.Gtk_Orientable) 
  471.    return Gtk_Range 
  472.    renames Implements_Gtk_Orientable.To_Object; 
  473.  
  474. private 
  475.    Upper_Stepper_Sensitivity_Property : constant Gtk.Enums.Property_Gtk_Sensitivity_Type := 
  476.      Gtk.Enums.Build ("upper-stepper-sensitivity"); 
  477.    Show_Fill_Level_Property : constant Glib.Properties.Property_Boolean := 
  478.      Glib.Properties.Build ("show-fill-level"); 
  479.    Round_Digits_Property : constant Glib.Properties.Property_Int := 
  480.      Glib.Properties.Build ("round-digits"); 
  481.    Restrict_To_Fill_Level_Property : constant Glib.Properties.Property_Boolean := 
  482.      Glib.Properties.Build ("restrict-to-fill-level"); 
  483.    Lower_Stepper_Sensitivity_Property : constant Gtk.Enums.Property_Gtk_Sensitivity_Type := 
  484.      Gtk.Enums.Build ("lower-stepper-sensitivity"); 
  485.    Inverted_Property : constant Glib.Properties.Property_Boolean := 
  486.      Glib.Properties.Build ("inverted"); 
  487.    Fill_Level_Property : constant Glib.Properties.Property_Double := 
  488.      Glib.Properties.Build ("fill-level"); 
  489.    Adjustment_Property : constant Glib.Properties.Property_Object := 
  490.      Glib.Properties.Build ("adjustment"); 
  491. end Gtk.GRange;