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. --  A GtkScale is a slider control used to select a numeric value. To use it, 
  26. --  you'll probably want to investigate the methods on its base class, 
  27. --  Gtk.GRange.Gtk_Range, in addition to the methods for GtkScale itself. To 
  28. --  set the value of a scale, you would normally use Gtk.GRange.Set_Value. To 
  29. --  detect changes to the value, you would normally use the 
  30. --  Gtk.GRange.Gtk_Range::value-changed signal. 
  31. -- 
  32. --  Note that using the same upper and lower bounds for the 
  33. --  Gtk.Scale.Gtk_Scale (through the Gtk.GRange.Gtk_Range methods) will hide 
  34. --  the slider itself. This is useful for applications that want to show an 
  35. --  undeterminate value on the scale, without changing the layout of the 
  36. --  application (such as movie or music players). 
  37. -- 
  38. --  == GtkScale as GtkBuildable == 
  39. -- 
  40. --  GtkScale supports a custom <marks> element, which can contain multiple 
  41. --  <mark> elements. The "value" and "position" attributes have the same 
  42. --  meaning as Gtk.Scale.Add_Mark parameters of the same name. If the element 
  43. --  is not empty, its content is taken as the markup to show at the mark. It 
  44. --  can be translated with the usual "translatable and "context" attributes. 
  45. -- 
  46. --  </description> 
  47. --  <screenshot>gtk-scale.png</screenshot> 
  48. --  <group>Numeric/Text Data Entry</group> 
  49. pragma Ada_2005; 
  50.  
  51. pragma Warnings (Off, "*is already use-visible*"); 
  52. with Glib;            use Glib; 
  53. with Glib.Object;     use Glib.Object; 
  54. with Glib.Properties; use Glib.Properties; 
  55. with Glib.Types;      use Glib.Types; 
  56. with Gtk.Adjustment;  use Gtk.Adjustment; 
  57. with Gtk.Buildable;   use Gtk.Buildable; 
  58. with Gtk.Enums;       use Gtk.Enums; 
  59. with Gtk.GRange;      use Gtk.GRange; 
  60. with Gtk.Orientable;  use Gtk.Orientable; 
  61. with Pango.Layout;    use Pango.Layout; 
  62.  
  63. package Gtk.Scale is 
  64.  
  65.    type Gtk_Scale_Record is new Gtk_Range_Record with null record; 
  66.    type Gtk_Scale is access all Gtk_Scale_Record'Class; 
  67.  
  68.    subtype Gtk_Hscale_Record is Gtk_Scale_Record; 
  69.    subtype Gtk_Hscale is Gtk_Scale; 
  70.  
  71.    subtype Gtk_Vscale_Record is Gtk_Scale_Record; 
  72.    subtype Gtk_Vscale is Gtk_Scale; 
  73.  
  74.    ------------------ 
  75.    -- Constructors -- 
  76.    ------------------ 
  77.  
  78.    procedure Gtk_New 
  79.       (Scale       : out Gtk_Scale; 
  80.        Orientation : Gtk.Enums.Gtk_Orientation; 
  81.        Adjustment  : access Gtk.Adjustment.Gtk_Adjustment_Record'Class); 
  82.    procedure Initialize 
  83.       (Scale       : not null access Gtk_Scale_Record'Class; 
  84.        Orientation : Gtk.Enums.Gtk_Orientation; 
  85.        Adjustment  : access Gtk.Adjustment.Gtk_Adjustment_Record'Class); 
  86.    --  Creates a new Gtk.Scale.Gtk_Scale. 
  87.    --  Since: gtk+ 3.0 
  88.    --  "orientation": the scale's orientation. 
  89.    --  "adjustment": the Gtk.Adjustment.Gtk_Adjustment which sets the range of 
  90.    --  the scale, or null to create a new adjustment. 
  91.  
  92.    function Gtk_Scale_New 
  93.       (Orientation : Gtk.Enums.Gtk_Orientation; 
  94.        Adjustment  : access Gtk.Adjustment.Gtk_Adjustment_Record'Class) 
  95.        return Gtk_Scale; 
  96.    --  Creates a new Gtk.Scale.Gtk_Scale. 
  97.    --  Since: gtk+ 3.0 
  98.    --  "orientation": the scale's orientation. 
  99.    --  "adjustment": the Gtk.Adjustment.Gtk_Adjustment which sets the range of 
  100.    --  the scale, or null to create a new adjustment. 
  101.  
  102.    procedure Gtk_New_With_Range 
  103.       (Scale       : out Gtk_Scale; 
  104.        Orientation : Gtk.Enums.Gtk_Orientation; 
  105.        Min         : Gdouble; 
  106.        Max         : Gdouble; 
  107.        Step        : Gdouble); 
  108.    procedure Initialize_With_Range 
  109.       (Scale       : not null access Gtk_Scale_Record'Class; 
  110.        Orientation : Gtk.Enums.Gtk_Orientation; 
  111.        Min         : Gdouble; 
  112.        Max         : Gdouble; 
  113.        Step        : Gdouble); 
  114.    --  Creates a new scale widget with the given orientation that lets the 
  115.    --  user input a number between Min and Max (including Min and Max) with the 
  116.    --  increment Step. Step must be nonzero; it's the distance the slider moves 
  117.    --  when using the arrow keys to adjust the scale value. 
  118.    --  Note that the way in which the precision is derived works best if Step 
  119.    --  is a power of ten. If the resulting precision is not suitable for your 
  120.    --  needs, use Gtk.Scale.Set_Digits to correct it. 
  121.    --  Since: gtk+ 3.0 
  122.    --  "orientation": the scale's orientation. 
  123.    --  "min": minimum value 
  124.    --  "max": maximum value 
  125.    --  "step": step increment (tick size) used with keyboard shortcuts 
  126.  
  127.    function Gtk_Scale_New_With_Range 
  128.       (Orientation : Gtk.Enums.Gtk_Orientation; 
  129.        Min         : Gdouble; 
  130.        Max         : Gdouble; 
  131.        Step        : Gdouble) return Gtk_Scale; 
  132.    --  Creates a new scale widget with the given orientation that lets the 
  133.    --  user input a number between Min and Max (including Min and Max) with the 
  134.    --  increment Step. Step must be nonzero; it's the distance the slider moves 
  135.    --  when using the arrow keys to adjust the scale value. 
  136.    --  Note that the way in which the precision is derived works best if Step 
  137.    --  is a power of ten. If the resulting precision is not suitable for your 
  138.    --  needs, use Gtk.Scale.Set_Digits to correct it. 
  139.    --  Since: gtk+ 3.0 
  140.    --  "orientation": the scale's orientation. 
  141.    --  "min": minimum value 
  142.    --  "max": maximum value 
  143.    --  "step": step increment (tick size) used with keyboard shortcuts 
  144.  
  145.    function Get_Type return Glib.GType; 
  146.    pragma Import (C, Get_Type, "gtk_scale_get_type"); 
  147.  
  148.    procedure Gtk_New_Hscale 
  149.       (Scale      : out Gtk_Hscale; 
  150.        Adjustment : Gtk.Adjustment.Gtk_Adjustment := null); 
  151.    procedure Initialize_Hscale 
  152.       (Scale      : not null access Gtk_Hscale_Record'Class; 
  153.        Adjustment : Gtk.Adjustment.Gtk_Adjustment := null); 
  154.    --  Creates a new Gtk.Scale.Gtk_Hscale. 
  155.    --  "adjustment": the Gtk.Adjustment.Gtk_Adjustment which sets the range of 
  156.    --  the scale. 
  157.  
  158.    procedure Gtk_New_Hscale 
  159.       (Scale : out Gtk_Hscale; 
  160.        Min   : Gdouble; 
  161.        Max   : Gdouble; 
  162.        Step  : Gdouble); 
  163.    procedure Initialize_Hscale 
  164.       (Scale : not null access Gtk_Hscale_Record'Class; 
  165.        Min   : Gdouble; 
  166.        Max   : Gdouble; 
  167.        Step  : Gdouble); 
  168.    --  Creates a new horizontal scale widget that lets the user input a number 
  169.    --  between Min and Max (including Min and Max) with the increment Step. 
  170.    --  Step must be nonzero; it's the distance the slider moves when using the 
  171.    --  arrow keys to adjust the scale value. 
  172.    --  Note that the way in which the precision is derived works best if Step 
  173.    --  is a power of ten. If the resulting precision is not suitable for your 
  174.    --  needs, use Gtk.Scale.Set_Digits to correct it. 
  175.    --  "min": minimum value 
  176.    --  "max": maximum value 
  177.    --  "step": step increment (tick size) used with keyboard shortcuts 
  178.  
  179.    function Gtk_Hscale_New 
  180.       (Adjustment : Gtk.Adjustment.Gtk_Adjustment := null) return Gtk_Hscale; 
  181.    --  Creates a new Gtk.Scale.Gtk_Hscale. 
  182.    --  "adjustment": the Gtk.Adjustment.Gtk_Adjustment which sets the range of 
  183.    --  the scale. 
  184.  
  185.    function Gtk_Hscale_New_With_Range 
  186.       (Min  : Gdouble; 
  187.        Max  : Gdouble; 
  188.        Step : Gdouble) return Gtk_Hscale; 
  189.    --  Creates a new horizontal scale widget that lets the user input a number 
  190.    --  between Min and Max (including Min and Max) with the increment Step. 
  191.    --  Step must be nonzero; it's the distance the slider moves when using the 
  192.    --  arrow keys to adjust the scale value. 
  193.    --  Note that the way in which the precision is derived works best if Step 
  194.    --  is a power of ten. If the resulting precision is not suitable for your 
  195.    --  needs, use Gtk.Scale.Set_Digits to correct it. 
  196.    --  "min": minimum value 
  197.    --  "max": maximum value 
  198.    --  "step": step increment (tick size) used with keyboard shortcuts 
  199.  
  200.    function Hscale_Get_Type return Glib.GType; 
  201.    pragma Import (C, Hscale_Get_Type, "gtk_hscale_get_type"); 
  202.  
  203.    procedure Gtk_New_Vscale 
  204.       (Scale      : out Gtk_Vscale; 
  205.        Adjustment : Gtk.Adjustment.Gtk_Adjustment := null); 
  206.    procedure Initialize_Vscale 
  207.       (Scale      : not null access Gtk_Vscale_Record'Class; 
  208.        Adjustment : Gtk.Adjustment.Gtk_Adjustment := null); 
  209.    --  Creates a new Gtk.Scale.Gtk_Vscale. 
  210.    --  "adjustment": the Gtk.Adjustment.Gtk_Adjustment which sets the range of 
  211.    --  the scale. 
  212.  
  213.    procedure Gtk_New_Vscale 
  214.       (Scale : out Gtk_Vscale; 
  215.        Min   : Gdouble; 
  216.        Max   : Gdouble; 
  217.        Step  : Gdouble); 
  218.    procedure Initialize_Vscale 
  219.       (Scale : not null access Gtk_Vscale_Record'Class; 
  220.        Min   : Gdouble; 
  221.        Max   : Gdouble; 
  222.        Step  : Gdouble); 
  223.    --  Creates a new vertical scale widget that lets the user input a number 
  224.    --  between Min and Max (including Min and Max) with the increment Step. 
  225.    --  Step must be nonzero; it's the distance the slider moves when using the 
  226.    --  arrow keys to adjust the scale value. 
  227.    --  Note that the way in which the precision is derived works best if Step 
  228.    --  is a power of ten. If the resulting precision is not suitable for your 
  229.    --  needs, use Gtk.Scale.Set_Digits to correct it. 
  230.    --  "min": minimum value 
  231.    --  "max": maximum value 
  232.    --  "step": step increment (tick size) used with keyboard shortcuts 
  233.  
  234.    function Gtk_Vscale_New 
  235.       (Adjustment : Gtk.Adjustment.Gtk_Adjustment := null) return Gtk_Vscale; 
  236.    --  Creates a new Gtk.Scale.Gtk_Vscale. 
  237.    --  "adjustment": the Gtk.Adjustment.Gtk_Adjustment which sets the range of 
  238.    --  the scale. 
  239.  
  240.    function Gtk_Vscale_New_With_Range 
  241.       (Min  : Gdouble; 
  242.        Max  : Gdouble; 
  243.        Step : Gdouble) return Gtk_Vscale; 
  244.    --  Creates a new vertical scale widget that lets the user input a number 
  245.    --  between Min and Max (including Min and Max) with the increment Step. 
  246.    --  Step must be nonzero; it's the distance the slider moves when using the 
  247.    --  arrow keys to adjust the scale value. 
  248.    --  Note that the way in which the precision is derived works best if Step 
  249.    --  is a power of ten. If the resulting precision is not suitable for your 
  250.    --  needs, use Gtk.Scale.Set_Digits to correct it. 
  251.    --  "min": minimum value 
  252.    --  "max": maximum value 
  253.    --  "step": step increment (tick size) used with keyboard shortcuts 
  254.  
  255.    function Vscale_Get_Type return Glib.GType; 
  256.    pragma Import (C, Vscale_Get_Type, "gtk_vscale_get_type"); 
  257.  
  258.    ------------- 
  259.    -- Methods -- 
  260.    ------------- 
  261.  
  262.    procedure Add_Mark 
  263.       (Scale    : not null access Gtk_Scale_Record; 
  264.        Value    : Gdouble; 
  265.        Position : Gtk.Enums.Gtk_Position_Type; 
  266.        Markup   : UTF8_String := ""); 
  267.    --  Adds a mark at Value. 
  268.    --  A mark is indicated visually by drawing a tick mark next to the scale, 
  269.    --  and GTK+ makes it easy for the user to position the scale exactly at the 
  270.    --  marks value. 
  271.    --  If Markup is not null, text is shown next to the tick mark. 
  272.    --  To remove marks from a scale, use Gtk.Scale.Clear_Marks. 
  273.    --  Since: gtk+ 2.16 
  274.    --  "value": the value at which the mark is placed, must be between the 
  275.    --  lower and upper limits of the scales' adjustment 
  276.    --  "position": where to draw the mark. For a horizontal scale, GTK_POS_TOP 
  277.    --  and Gtk.Enums.Pos_Left are drawn above the scale, anything else below. 
  278.    --  For a vertical scale, GTK_POS_LEFT and Gtk.Enums.Pos_Top are drawn to 
  279.    --  the left of the scale, anything else to the right. 
  280.    --  "markup": Text to be shown at the mark, using <link 
  281.    --  linkend="PangoMarkupFormat">Pango markup</link>, or null 
  282.  
  283.    procedure Clear_Marks (Scale : not null access Gtk_Scale_Record); 
  284.    --  Removes any marks that have been added with Gtk.Scale.Add_Mark. 
  285.    --  Since: gtk+ 2.16 
  286.  
  287.    function Get_Digits 
  288.       (Scale : not null access Gtk_Scale_Record) return Gint; 
  289.    --  Gets the number of decimal places that are displayed in the value. 
  290.  
  291.    procedure Set_Digits 
  292.       (Scale      : not null access Gtk_Scale_Record; 
  293.        The_Digits : Gint); 
  294.    --  Sets the number of decimal places that are displayed in the value. Also 
  295.    --  causes the value of the adjustment to be rounded off to this number of 
  296.    --  digits, so the retrieved value matches the value the user saw. 
  297.    --  "digits": the number of decimal places to display, e.g. use 1 to 
  298.    --  display 1.0, 2 to display 1.00, etc 
  299.  
  300.    function Get_Draw_Value 
  301.       (Scale : not null access Gtk_Scale_Record) return Boolean; 
  302.    --  Returns whether the current value is displayed as a string next to the 
  303.    --  slider. 
  304.  
  305.    procedure Set_Draw_Value 
  306.       (Scale      : not null access Gtk_Scale_Record; 
  307.        Draw_Value : Boolean); 
  308.    --  Specifies whether the current value is displayed as a string next to 
  309.    --  the slider. 
  310.    --  "draw_value": True to draw the value 
  311.  
  312.    function Get_Has_Origin 
  313.       (Scale : not null access Gtk_Scale_Record) return Boolean; 
  314.    --  Returns whether the scale has an origin. 
  315.    --  Since: gtk+ 3.4 
  316.  
  317.    procedure Set_Has_Origin 
  318.       (Scale      : not null access Gtk_Scale_Record; 
  319.        Has_Origin : Boolean); 
  320.    --  If Has_Origin is set to True (the default), the scale will highlight 
  321.    --  the part of the scale between the origin (bottom or left side) of the 
  322.    --  scale and the current value. 
  323.    --  Since: gtk+ 3.4 
  324.    --  "has_origin": True if the scale has an origin 
  325.  
  326.    function Get_Layout 
  327.       (Scale : not null access Gtk_Scale_Record) 
  328.        return Pango.Layout.Pango_Layout; 
  329.    --  Gets the Pango.Layout.Pango_Layout used to display the scale. The 
  330.    --  returned object is owned by the scale so does not need to be freed by 
  331.    --  the caller. 
  332.    --  Since: gtk+ 2.4 
  333.  
  334.    procedure Get_Layout_Offsets 
  335.       (Scale : not null access Gtk_Scale_Record; 
  336.        X     : out Gint; 
  337.        Y     : out Gint); 
  338.    --  Obtains the coordinates where the scale will draw the 
  339.    --  Pango.Layout.Pango_Layout representing the text in the scale. Remember 
  340.    --  when using the Pango.Layout.Pango_Layout function you need to convert to 
  341.    --  and from pixels using PANGO_PIXELS or PANGO_SCALE. 
  342.    --  If the Gtk.Scale.Gtk_Scale:draw-value property is False, the return 
  343.    --  values are undefined. 
  344.    --  Since: gtk+ 2.4 
  345.    --  "x": location to store X offset of layout, or null 
  346.    --  "y": location to store Y offset of layout, or null 
  347.  
  348.    function Get_Value_Pos 
  349.       (Scale : not null access Gtk_Scale_Record) 
  350.        return Gtk.Enums.Gtk_Position_Type; 
  351.    --  Gets the position in which the current value is displayed. 
  352.  
  353.    procedure Set_Value_Pos 
  354.       (Scale : not null access Gtk_Scale_Record; 
  355.        Pos   : Gtk.Enums.Gtk_Position_Type); 
  356.    --  Sets the position in which the current value is displayed. 
  357.    --  "pos": the position in which the current value is displayed 
  358.  
  359.    --------------------------------------------- 
  360.    -- Inherited subprograms (from interfaces) -- 
  361.    --------------------------------------------- 
  362.    --  Methods inherited from the Buildable interface are not duplicated here 
  363.    --  since they are meant to be used by tools, mostly. If you need to call 
  364.    --  them, use an explicit cast through the "-" operator below. 
  365.  
  366.    function Get_Orientation 
  367.       (Self : not null access Gtk_Scale_Record) 
  368.        return Gtk.Enums.Gtk_Orientation; 
  369.  
  370.    procedure Set_Orientation 
  371.       (Self        : not null access Gtk_Scale_Record; 
  372.        Orientation : Gtk.Enums.Gtk_Orientation); 
  373.  
  374.    ---------------- 
  375.    -- Properties -- 
  376.    ---------------- 
  377.    --  The following properties are defined for this widget. See 
  378.    --  Glib.Properties for more information on properties) 
  379.  
  380.    The_Digits_Property : constant Glib.Properties.Property_Int; 
  381.  
  382.    Draw_Value_Property : constant Glib.Properties.Property_Boolean; 
  383.  
  384.    Has_Origin_Property : constant Glib.Properties.Property_Boolean; 
  385.  
  386.    Value_Pos_Property : constant Gtk.Enums.Property_Gtk_Position_Type; 
  387.  
  388.    ------------- 
  389.    -- Signals -- 
  390.    ------------- 
  391.  
  392.    type Cb_Gtk_Scale_Gdouble_UTF8_String is not null access function 
  393.      (Self  : access Gtk_Scale_Record'Class; 
  394.       Value : Gdouble) return UTF8_String; 
  395.  
  396.    type Cb_GObject_Gdouble_UTF8_String is not null access function 
  397.      (Self  : access Glib.Object.GObject_Record'Class; 
  398.       Value : Gdouble) return UTF8_String; 
  399.  
  400.    Signal_Format_Value : constant Glib.Signal_Name := "format-value"; 
  401.    procedure On_Format_Value 
  402.       (Self  : not null access Gtk_Scale_Record; 
  403.        Call  : Cb_Gtk_Scale_Gdouble_UTF8_String; 
  404.        After : Boolean := False); 
  405.    procedure On_Format_Value 
  406.       (Self  : not null access Gtk_Scale_Record; 
  407.        Call  : Cb_GObject_Gdouble_UTF8_String; 
  408.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  409.        After : Boolean := False); 
  410.    --  Signal which allows you to change how the scale value is displayed. 
  411.    --  Connect a signal handler which returns an allocated string representing 
  412.    --  Value. That string will then be used to display the scale's value. 
  413.    -- 
  414.    --  Here's an example signal handler which displays a value 1.0 as with 
  415.    --  "-->1.0<--". |[ static gchar* format_value_callback (GtkScale *scale, 
  416.    --  gdouble value) { return g_strdup_printf ("-->%0.*g<--", 
  417.    --  gtk_scale_get_digits (scale), value); } ]| 
  418.    --  
  419.    --  Callback parameters: 
  420.    --    --  "value": the value to format 
  421.    --    --  Returns allocated string representing Value 
  422.  
  423.    ---------------- 
  424.    -- Interfaces -- 
  425.    ---------------- 
  426.    --  This class implements several interfaces. See Glib.Types 
  427.    -- 
  428.    --  - "Buildable" 
  429.    -- 
  430.    --  - "Orientable" 
  431.  
  432.    package Implements_Gtk_Buildable is new Glib.Types.Implements 
  433.      (Gtk.Buildable.Gtk_Buildable, Gtk_Scale_Record, Gtk_Scale); 
  434.    function "+" 
  435.      (Widget : access Gtk_Scale_Record'Class) 
  436.    return Gtk.Buildable.Gtk_Buildable 
  437.    renames Implements_Gtk_Buildable.To_Interface; 
  438.    function "-" 
  439.      (Interf : Gtk.Buildable.Gtk_Buildable) 
  440.    return Gtk_Scale 
  441.    renames Implements_Gtk_Buildable.To_Object; 
  442.  
  443.    package Implements_Gtk_Orientable is new Glib.Types.Implements 
  444.      (Gtk.Orientable.Gtk_Orientable, Gtk_Scale_Record, Gtk_Scale); 
  445.    function "+" 
  446.      (Widget : access Gtk_Scale_Record'Class) 
  447.    return Gtk.Orientable.Gtk_Orientable 
  448.    renames Implements_Gtk_Orientable.To_Interface; 
  449.    function "-" 
  450.      (Interf : Gtk.Orientable.Gtk_Orientable) 
  451.    return Gtk_Scale 
  452.    renames Implements_Gtk_Orientable.To_Object; 
  453.  
  454. private 
  455.    Value_Pos_Property : constant Gtk.Enums.Property_Gtk_Position_Type := 
  456.      Gtk.Enums.Build ("value-pos"); 
  457.    Has_Origin_Property : constant Glib.Properties.Property_Boolean := 
  458.      Glib.Properties.Build ("has-origin"); 
  459.    Draw_Value_Property : constant Glib.Properties.Property_Boolean := 
  460.      Glib.Properties.Build ("draw-value"); 
  461.    The_Digits_Property : constant Glib.Properties.Property_Int := 
  462.      Glib.Properties.Build ("digits"); 
  463. end Gtk.Scale;