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. --  The Gtk.GEntry.Gtk_Entry widget is a single line text entry widget. A 
  26. --  fairly large set of key bindings are supported by default. If the entered 
  27. --  text is longer than the allocation of the widget, the widget will scroll so 
  28. --  that the cursor position is visible. 
  29. -- 
  30. --  When using an entry for passwords and other sensitive information, it can 
  31. --  be put into "password mode" using Gtk.GEntry.Set_Visibility. In this mode, 
  32. --  entered text is displayed using a 'invisible' character. By default, GTK+ 
  33. --  picks the best invisible character that is available in the current font, 
  34. --  but it can be changed with Gtk.GEntry.Set_Invisible_Char. Since 2.16, GTK+ 
  35. --  displays a warning when Caps Lock or input methods might interfere with 
  36. --  entering text in a password entry. The warning can be turned off with the 
  37. --  Gtk.GEntry.Gtk_Entry:caps-lock-warning property. 
  38. -- 
  39. --  Since 2.16, GtkEntry has the ability to display progress or activity 
  40. --  information behind the text. To make an entry display such information, use 
  41. --  Gtk.GEntry.Set_Progress_Fraction or Gtk.GEntry.Set_Progress_Pulse_Step. 
  42. -- 
  43. --  Additionally, GtkEntry can show icons at either side of the entry. These 
  44. --  icons can be activatable by clicking, can be set up as drag source and can 
  45. --  have tooltips. To add an icon, use Gtk.GEntry.Set_Icon_From_Gicon or one of 
  46. --  the various other functions that set an icon from a stock id, an icon name 
  47. --  or a pixbuf. To trigger an action when the user clicks an icon, connect to 
  48. --  the Gtk.GEntry.Gtk_Entry::icon-press signal. To allow DND operations from 
  49. --  an icon, use Gtk.GEntry.Set_Icon_Drag_Source. To set a tooltip on an icon, 
  50. --  use Gtk.GEntry.Set_Icon_Tooltip_Text or the corresponding function for 
  51. --  markup. 
  52. -- 
  53. --  Note that functionality or information that is only available by clicking 
  54. --  on an icon in an entry may not be accessible at all to users which are not 
  55. --  able to use a mouse or other pointing device. It is therefore recommended 
  56. --  that any such functionality should also be available by other means, e.g. 
  57. --  via the context menu of the entry. 
  58. -- 
  59. --  </description> 
  60. --  <description> 
  61. --  A Gtk_Entry is a single line text editing widget. The text is 
  62. --  automatically scrolled if it is longer than can be displayed on the screen, 
  63. --  so that the cursor position is visible at all times. 
  64. -- 
  65. --  See Gtk_Text_View for a multiple-line text editing widget. 
  66. -- 
  67. --  </description> 
  68. --  <screenshot>gtk-gentry</screenshot> 
  69. --  <group>Numeric/Text Data Entry</group> 
  70. --  <testgtk>create_entry.adb</testgtk> 
  71. pragma Ada_2005; 
  72.  
  73. pragma Warnings (Off, "*is already use-visible*"); 
  74. with Gdk.Drag_Contexts;       use Gdk.Drag_Contexts; 
  75. with Gdk.Event;               use Gdk.Event; 
  76. with Gdk.Pixbuf;              use Gdk.Pixbuf; 
  77. with Gdk.Rectangle;           use Gdk.Rectangle; 
  78. with Glib;                    use Glib; 
  79. with Glib.G_Icon;             use Glib.G_Icon; 
  80. with Glib.Generic_Properties; use Glib.Generic_Properties; 
  81. with Glib.Object;             use Glib.Object; 
  82. with Glib.Properties;         use Glib.Properties; 
  83. with Glib.Types;              use Glib.Types; 
  84. with Gtk.Adjustment;          use Gtk.Adjustment; 
  85. with Gtk.Buildable;           use Gtk.Buildable; 
  86. with Gtk.Cell_Editable;       use Gtk.Cell_Editable; 
  87. with Gtk.Editable;            use Gtk.Editable; 
  88. with Gtk.Entry_Buffer;        use Gtk.Entry_Buffer; 
  89. with Gtk.Entry_Completion;    use Gtk.Entry_Completion; 
  90. with Gtk.Enums;               use Gtk.Enums; 
  91. with Gtk.Image;               use Gtk.Image; 
  92. with Gtk.Style;               use Gtk.Style; 
  93. with Gtk.Target_List;         use Gtk.Target_List; 
  94. with Gtk.Widget;              use Gtk.Widget; 
  95. with Pango.Attributes;        use Pango.Attributes; 
  96. with Pango.Layout;            use Pango.Layout; 
  97.  
  98. package Gtk.GEntry is 
  99.  
  100.    type Gtk_Entry_Record is new Gtk_Widget_Record with null record; 
  101.    type Gtk_Entry is access all Gtk_Entry_Record'Class; 
  102.  
  103.    type Gtk_Entry_Icon_Position is ( 
  104.       Gtk_Entry_Icon_Primary, 
  105.       Gtk_Entry_Icon_Secondary); 
  106.    pragma Convention (C, Gtk_Entry_Icon_Position); 
  107.    --  Specifies the side of the entry at which an icon is placed. 
  108.  
  109.    ---------------------------- 
  110.    -- Enumeration Properties -- 
  111.    ---------------------------- 
  112.  
  113.    package Gtk_Entry_Icon_Position_Properties is 
  114.       new Generic_Internal_Discrete_Property (Gtk_Entry_Icon_Position); 
  115.    type Property_Gtk_Entry_Icon_Position is new Gtk_Entry_Icon_Position_Properties.Property; 
  116.  
  117.    ------------------ 
  118.    -- Constructors -- 
  119.    ------------------ 
  120.  
  121.    procedure Gtk_New (The_Entry : out Gtk_Entry); 
  122.    procedure Initialize (The_Entry : not null access Gtk_Entry_Record'Class); 
  123.    --  Creates a new entry. 
  124.  
  125.    function Gtk_Entry_New return Gtk_Entry; 
  126.    --  Creates a new entry. 
  127.  
  128.    procedure Gtk_New_With_Buffer 
  129.       (The_Entry : out Gtk_Entry; 
  130.        Buffer    : not null access Gtk.Entry_Buffer.Gtk_Entry_Buffer_Record'Class); 
  131.    procedure Initialize_With_Buffer 
  132.       (The_Entry : not null access Gtk_Entry_Record'Class; 
  133.        Buffer    : not null access Gtk.Entry_Buffer.Gtk_Entry_Buffer_Record'Class); 
  134.    --  Creates a new entry with the specified text buffer. 
  135.    --  Since: gtk+ 2.18 
  136.    --  "buffer": The buffer to use for the new Gtk.GEntry.Gtk_Entry. 
  137.  
  138.    function Gtk_Entry_New_With_Buffer 
  139.       (Buffer : not null access Gtk.Entry_Buffer.Gtk_Entry_Buffer_Record'Class) 
  140.        return Gtk_Entry; 
  141.    --  Creates a new entry with the specified text buffer. 
  142.    --  Since: gtk+ 2.18 
  143.    --  "buffer": The buffer to use for the new Gtk.GEntry.Gtk_Entry. 
  144.  
  145.    function Get_Type return Glib.GType; 
  146.    pragma Import (C, Get_Type, "gtk_entry_get_type"); 
  147.  
  148.    ------------- 
  149.    -- Methods -- 
  150.    ------------- 
  151.  
  152.    function Get_Activates_Default 
  153.       (The_Entry : not null access Gtk_Entry_Record) return Boolean; 
  154.    --  Retrieves the value set by Gtk.GEntry.Set_Activates_Default. 
  155.  
  156.    procedure Set_Activates_Default 
  157.       (The_Entry : not null access Gtk_Entry_Record; 
  158.        Setting   : Boolean); 
  159.    --  If Setting is True, pressing Enter in the Entry will activate the 
  160.    --  default widget for the window containing the entry. This usually means 
  161.    --  that the dialog box containing the entry will be closed, since the 
  162.    --  default widget is usually one of the dialog buttons. 
  163.    --  (For experts: if Setting is True, the entry calls 
  164.    --  Gtk.Window.Activate_Default on the window containing the entry, in the 
  165.    --  default handler for the Gtk.GEntry.Gtk_Entry::activate signal.) 
  166.    --  "setting": True to activate window's default widget on Enter keypress 
  167.  
  168.    function Get_Alignment 
  169.       (The_Entry : not null access Gtk_Entry_Record) return Gfloat; 
  170.    --  Gets the value set by Gtk.GEntry.Set_Alignment. 
  171.    --  Since: gtk+ 2.4 
  172.  
  173.    procedure Set_Alignment 
  174.       (The_Entry : not null access Gtk_Entry_Record; 
  175.        Xalign    : Gfloat); 
  176.    --  Sets the alignment for the contents of the entry. This controls the 
  177.    --  horizontal positioning of the contents when the displayed text is 
  178.    --  shorter than the width of the entry. 
  179.    --  Since: gtk+ 2.4 
  180.    --  "xalign": The horizontal alignment, from 0 (left) to 1 (right). 
  181.    --  Reversed for RTL layouts 
  182.  
  183.    function Get_Attributes 
  184.       (The_Entry : not null access Gtk_Entry_Record) 
  185.        return Pango.Attributes.Pango_Attr_List; 
  186.    --  Gets the attribute list that was set on the entry using 
  187.    --  Gtk.GEntry.Set_Attributes, if any. 
  188.    --  Since: gtk+ 3.6 
  189.  
  190.    procedure Set_Attributes 
  191.       (The_Entry : not null access Gtk_Entry_Record; 
  192.        Attrs     : Pango.Attributes.Pango_Attr_List); 
  193.    --  Sets a Pango.Attributes.Pango_Attr_List; the attributes in the list are 
  194.    --  applied to the entry text. 
  195.    --  Since: gtk+ 3.6 
  196.    --  "attrs": a Pango.Attributes.Pango_Attr_List 
  197.  
  198.    function Get_Buffer 
  199.       (The_Entry : not null access Gtk_Entry_Record) 
  200.        return Gtk.Entry_Buffer.Gtk_Entry_Buffer; 
  201.    --  Get the Gtk.Entry_Buffer.Gtk_Entry_Buffer object which holds the text 
  202.    --  for this widget. 
  203.    --  Since: gtk+ 2.18 
  204.  
  205.    procedure Set_Buffer 
  206.       (The_Entry : not null access Gtk_Entry_Record; 
  207.        Buffer    : not null access Gtk.Entry_Buffer.Gtk_Entry_Buffer_Record'Class); 
  208.    --  Set the Gtk.Entry_Buffer.Gtk_Entry_Buffer object which holds the text 
  209.    --  for this widget. 
  210.    --  Since: gtk+ 2.18 
  211.    --  "buffer": a Gtk.Entry_Buffer.Gtk_Entry_Buffer 
  212.  
  213.    function Get_Completion 
  214.       (The_Entry : not null access Gtk_Entry_Record) 
  215.        return Gtk.Entry_Completion.Gtk_Entry_Completion; 
  216.    --  Returns the auxiliary completion object currently in use by Entry. 
  217.    --  Since: gtk+ 2.4 
  218.  
  219.    procedure Set_Completion 
  220.       (The_Entry  : not null access Gtk_Entry_Record; 
  221.        Completion : access Gtk.Entry_Completion.Gtk_Entry_Completion_Record'Class); 
  222.    --  Sets Completion to be the auxiliary completion object to use with 
  223.    --  Entry. All further configuration of the completion mechanism is done on 
  224.    --  Completion using the Gtk.Entry_Completion.Gtk_Entry_Completion API. 
  225.    --  Completion is disabled if Completion is set to null. 
  226.    --  Since: gtk+ 2.4 
  227.    --  "completion": The Gtk.Entry_Completion.Gtk_Entry_Completion or null 
  228.  
  229.    function Get_Current_Icon_Drag_Source 
  230.       (The_Entry : not null access Gtk_Entry_Record) return Gint; 
  231.    --  Returns the index of the icon which is the source of the current DND 
  232.    --  operation, or -1. 
  233.    --  This function is meant to be used in a 
  234.    --  Gtk.Widget.Gtk_Widget::drag-data-get callback. 
  235.    --  Since: gtk+ 2.16 
  236.  
  237.    function Get_Cursor_Hadjustment 
  238.       (The_Entry : not null access Gtk_Entry_Record) 
  239.        return Gtk.Adjustment.Gtk_Adjustment; 
  240.    --  Retrieves the horizontal cursor adjustment for the entry. See 
  241.    --  Gtk.GEntry.Set_Cursor_Hadjustment. 
  242.    --  Since: gtk+ 2.12 
  243.  
  244.    procedure Set_Cursor_Hadjustment 
  245.       (The_Entry  : not null access Gtk_Entry_Record; 
  246.        Adjustment : not null access Gtk.Adjustment.Gtk_Adjustment_Record'Class); 
  247.    --  Hooks up an adjustment to the cursor position in an entry, so that when 
  248.    --  the cursor is moved, the adjustment is scrolled to show that position. 
  249.    --  See Gtk.Scrolled_Window.Get_Hadjustment for a typical way of obtaining 
  250.    --  the adjustment. 
  251.    --  The adjustment has to be in pixel units and in the same coordinate 
  252.    --  system as the entry. 
  253.    --  Since: gtk+ 2.12 
  254.    --  "adjustment": an adjustment which should be adjusted when the cursor is 
  255.    --  moved, or null 
  256.  
  257.    function Get_Has_Frame 
  258.       (The_Entry : not null access Gtk_Entry_Record) return Boolean; 
  259.    --  Gets the value set by Gtk.GEntry.Set_Has_Frame. 
  260.  
  261.    procedure Set_Has_Frame 
  262.       (The_Entry : not null access Gtk_Entry_Record; 
  263.        Setting   : Boolean := True); 
  264.    --  Sets whether the entry has a beveled frame around it. 
  265.    --  "setting": new value 
  266.  
  267.    function Get_Icon_Activatable 
  268.       (The_Entry : not null access Gtk_Entry_Record; 
  269.        Icon_Pos  : Gtk_Entry_Icon_Position) return Boolean; 
  270.    --  Returns whether the icon is activatable. 
  271.    --  Since: gtk+ 2.16 
  272.    --  "icon_pos": Icon position 
  273.  
  274.    procedure Set_Icon_Activatable 
  275.       (The_Entry   : not null access Gtk_Entry_Record; 
  276.        Icon_Pos    : Gtk_Entry_Icon_Position; 
  277.        Activatable : Boolean); 
  278.    --  Sets whether the icon is activatable. 
  279.    --  Since: gtk+ 2.16 
  280.    --  "icon_pos": Icon position 
  281.    --  "activatable": True if the icon should be activatable 
  282.  
  283.    procedure Get_Icon_Area 
  284.       (The_Entry : not null access Gtk_Entry_Record; 
  285.        Icon_Pos  : Gtk_Entry_Icon_Position; 
  286.        Icon_Area : out Gdk.Rectangle.Gdk_Rectangle); 
  287.    --  Gets the area where entry's icon at Icon_Pos is drawn. This function is 
  288.    --  useful when drawing something to the entry in a draw callback. 
  289.    --  If the entry is not realized or has no icon at the given position, 
  290.    --  Icon_Area is filled with zeros. 
  291.    --  See also Gtk.GEntry.Get_Text_Area 
  292.    --  Since: gtk+ 3.0 
  293.    --  "icon_pos": Icon position 
  294.    --  "icon_area": Return location for the icon's area 
  295.  
  296.    function Get_Icon_At_Pos 
  297.       (The_Entry : not null access Gtk_Entry_Record; 
  298.        X         : Gint; 
  299.        Y         : Gint) return Gint; 
  300.    --  Finds the icon at the given position and return its index. The 
  301.    --  position's coordinates are relative to the Entry's top left corner. If 
  302.    --  X, Y doesn't lie inside an icon, -1 is returned. This function is 
  303.    --  intended for use in a Gtk.Widget.Gtk_Widget::query-tooltip signal 
  304.    --  handler. 
  305.    --  Since: gtk+ 2.16 
  306.    --  "x": the x coordinate of the position to find 
  307.    --  "y": the y coordinate of the position to find 
  308.  
  309.    function Get_Icon_Gicon 
  310.       (The_Entry : not null access Gtk_Entry_Record; 
  311.        Icon_Pos  : Gtk_Entry_Icon_Position) return Glib.G_Icon.G_Icon; 
  312.    --  Retrieves the Glib.G_Icon.G_Icon used for the icon, or null if there is 
  313.    --  no icon or if the icon was set by some other method (e.g., by stock, 
  314.    --  pixbuf, or icon name). 
  315.    --  Since: gtk+ 2.16 
  316.    --  "icon_pos": Icon position 
  317.  
  318.    function Get_Icon_Name 
  319.       (The_Entry : not null access Gtk_Entry_Record; 
  320.        Icon_Pos  : Gtk_Entry_Icon_Position) return UTF8_String; 
  321.    --  Retrieves the icon name used for the icon, or null if there is no icon 
  322.    --  or if the icon was set by some other method (e.g., by pixbuf, stock or 
  323.    --  gicon). 
  324.    --  Since: gtk+ 2.16 
  325.    --  "icon_pos": Icon position 
  326.  
  327.    function Get_Icon_Pixbuf 
  328.       (The_Entry : not null access Gtk_Entry_Record; 
  329.        Icon_Pos  : Gtk_Entry_Icon_Position) return Gdk.Pixbuf.Gdk_Pixbuf; 
  330.    --  Retrieves the image used for the icon. 
  331.    --  Unlike the other methods of setting and getting icon data, this method 
  332.    --  will work regardless of whether the icon was set using a 
  333.    --  Gdk.Pixbuf.Gdk_Pixbuf, a Glib.G_Icon.G_Icon, a stock item, or an icon 
  334.    --  name. 
  335.    --  Since: gtk+ 2.16 
  336.    --  "icon_pos": Icon position 
  337.  
  338.    function Get_Icon_Sensitive 
  339.       (The_Entry : not null access Gtk_Entry_Record; 
  340.        Icon_Pos  : Gtk_Entry_Icon_Position) return Boolean; 
  341.    --  Returns whether the icon appears sensitive or insensitive. 
  342.    --  Since: gtk+ 2.16 
  343.    --  "icon_pos": Icon position 
  344.  
  345.    procedure Set_Icon_Sensitive 
  346.       (The_Entry : not null access Gtk_Entry_Record; 
  347.        Icon_Pos  : Gtk_Entry_Icon_Position; 
  348.        Sensitive : Boolean); 
  349.    --  Sets the sensitivity for the specified icon. 
  350.    --  Since: gtk+ 2.16 
  351.    --  "icon_pos": Icon position 
  352.    --  "sensitive": Specifies whether the icon should appear sensitive or 
  353.    --  insensitive 
  354.  
  355.    function Get_Icon_Stock 
  356.       (The_Entry : not null access Gtk_Entry_Record; 
  357.        Icon_Pos  : Gtk_Entry_Icon_Position) return UTF8_String; 
  358.    --  Retrieves the stock id used for the icon, or null if there is no icon 
  359.    --  or if the icon was set by some other method (e.g., by pixbuf, icon name 
  360.    --  or gicon). 
  361.    --  Since: gtk+ 2.16 
  362.    --  "icon_pos": Icon position 
  363.  
  364.    function Get_Icon_Storage_Type 
  365.       (The_Entry : not null access Gtk_Entry_Record; 
  366.        Icon_Pos  : Gtk_Entry_Icon_Position) return Gtk.Image.Gtk_Image_Type; 
  367.    --  Gets the type of representation being used by the icon to store image 
  368.    --  data. If the icon has no image data, the return value will be 
  369.    --  Gtk.Image.Image_Empty. 
  370.    --  Since: gtk+ 2.16 
  371.    --  "icon_pos": Icon position 
  372.  
  373.    function Get_Icon_Tooltip_Markup 
  374.       (The_Entry : not null access Gtk_Entry_Record; 
  375.        Icon_Pos  : Gtk_Entry_Icon_Position) return UTF8_String; 
  376.    --  Gets the contents of the tooltip on the icon at the specified position 
  377.    --  in Entry. 
  378.    --  Since: gtk+ 2.16 
  379.    --  "icon_pos": the icon position 
  380.  
  381.    procedure Set_Icon_Tooltip_Markup 
  382.       (The_Entry : not null access Gtk_Entry_Record; 
  383.        Icon_Pos  : Gtk_Entry_Icon_Position; 
  384.        Tooltip   : UTF8_String := ""); 
  385.    --  Sets Tooltip as the contents of the tooltip for the icon at the 
  386.    --  specified position. Tooltip is assumed to be marked up with the <link 
  387.    --  linkend="PangoMarkupFormat">Pango text markup language</link>. 
  388.    --  Use null for Tooltip to remove an existing tooltip. 
  389.    --  See also Gtk.Widget.Set_Tooltip_Markup and 
  390.    --  Gtk.GEntry.Set_Icon_Tooltip_Text. 
  391.    --  Since: gtk+ 2.16 
  392.    --  "icon_pos": the icon position 
  393.    --  "tooltip": the contents of the tooltip for the icon, or null 
  394.  
  395.    function Get_Icon_Tooltip_Text 
  396.       (The_Entry : not null access Gtk_Entry_Record; 
  397.        Icon_Pos  : Gtk_Entry_Icon_Position) return UTF8_String; 
  398.    --  Gets the contents of the tooltip on the icon at the specified position 
  399.    --  in Entry. 
  400.    --  Since: gtk+ 2.16 
  401.    --  "icon_pos": the icon position 
  402.  
  403.    procedure Set_Icon_Tooltip_Text 
  404.       (The_Entry : not null access Gtk_Entry_Record; 
  405.        Icon_Pos  : Gtk_Entry_Icon_Position; 
  406.        Tooltip   : UTF8_String := ""); 
  407.    --  Sets Tooltip as the contents of the tooltip for the icon at the 
  408.    --  specified position. 
  409.    --  Use null for Tooltip to remove an existing tooltip. 
  410.    --  See also Gtk.Widget.Set_Tooltip_Text and 
  411.    --  Gtk.GEntry.Set_Icon_Tooltip_Markup. 
  412.    --  Since: gtk+ 2.16 
  413.    --  "icon_pos": the icon position 
  414.    --  "tooltip": the contents of the tooltip for the icon, or null 
  415.  
  416.    function Get_Inner_Border 
  417.       (The_Entry : not null access Gtk_Entry_Record) 
  418.        return Gtk.Style.Gtk_Border; 
  419.    pragma Obsolescent (Get_Inner_Border); 
  420.    --  This function returns the entry's Gtk.GEntry.Gtk_Entry:inner-border 
  421.    --  property. See Gtk.GEntry.Set_Inner_Border for more information. 
  422.    --  Since: gtk+ 2.10 
  423.    --  Deprecated since 3.4, Use the standard border and padding CSS 
  424.    --  properties (through objects like Gtk.Style_Context.Gtk_Style_Context and 
  425.    --  Gtk.Css_Provider.Gtk_Css_Provider); the value returned by this function 
  426.    --  is ignored by Gtk.GEntry.Gtk_Entry. 
  427.  
  428.    procedure Set_Inner_Border 
  429.       (The_Entry : not null access Gtk_Entry_Record; 
  430.        Border    : Gtk.Style.Gtk_Border); 
  431.    pragma Obsolescent (Set_Inner_Border); 
  432.    --  Sets %entry's inner-border property to %border, or clears it if null is 
  433.    --  passed. The inner-border is the area around the entry's text, but inside 
  434.    --  its frame. 
  435.    --  If set, this property overrides the inner-border style property. 
  436.    --  Overriding the style-provided border is useful when you want to do 
  437.    --  in-place editing of some text in a canvas or list widget, where 
  438.    --  pixel-exact positioning of the entry is important. 
  439.    --  Since: gtk+ 2.10 
  440.    --  Deprecated since 3.4, Use the standard border and padding CSS 
  441.    --  properties (through objects like Gtk.Style_Context.Gtk_Style_Context and 
  442.    --  Gtk.Css_Provider.Gtk_Css_Provider); the value set with this function is 
  443.    --  ignored by Gtk.GEntry.Gtk_Entry. 
  444.    --  "border": a Gtk.Style.Gtk_Border, or null 
  445.  
  446.    function Get_Input_Hints 
  447.       (The_Entry : not null access Gtk_Entry_Record) 
  448.        return Gtk.Enums.Gtk_Input_Hints; 
  449.    --  Gets the value of the Gtk.GEntry.Gtk_Entry:input-hints property. 
  450.    --  Since: gtk+ 3.6 
  451.  
  452.    procedure Set_Input_Hints 
  453.       (The_Entry : not null access Gtk_Entry_Record; 
  454.        Hints     : Gtk.Enums.Gtk_Input_Hints); 
  455.    --  Sets the Gtk.GEntry.Gtk_Entry:input-hints property, which allows input 
  456.    --  methods to fine-tune their behaviour. 
  457.    --  Since: gtk+ 3.6 
  458.    --  "hints": the hints 
  459.  
  460.    function Get_Input_Purpose 
  461.       (The_Entry : not null access Gtk_Entry_Record) 
  462.        return Gtk.Enums.Gtk_Input_Purpose; 
  463.    --  Gets the value of the Gtk.GEntry.Gtk_Entry:input-purpose property. 
  464.    --  Since: gtk+ 3.6 
  465.  
  466.    procedure Set_Input_Purpose 
  467.       (The_Entry : not null access Gtk_Entry_Record; 
  468.        Purpose   : Gtk.Enums.Gtk_Input_Purpose); 
  469.    --  Sets the Gtk.GEntry.Gtk_Entry:input-purpose property which can be used 
  470.    --  by on-screen keyboards and other input methods to adjust their 
  471.    --  behaviour. 
  472.    --  Since: gtk+ 3.6 
  473.    --  "purpose": the purpose 
  474.  
  475.    function Get_Invisible_Char 
  476.       (The_Entry : not null access Gtk_Entry_Record) return Gunichar; 
  477.    --  Retrieves the character displayed in place of the real characters for 
  478.    --  entries with visibility set to false. See Gtk.GEntry.Set_Invisible_Char. 
  479.  
  480.    procedure Set_Invisible_Char 
  481.       (The_Entry : not null access Gtk_Entry_Record; 
  482.        Char      : Gunichar); 
  483.    --  Sets the character to use in place of the actual text when 
  484.    --  Gtk.GEntry.Set_Visibility has been called to set text visibility to 
  485.    --  False. i.e. this is the character used in "password mode" to show the 
  486.    --  user how many characters have been typed. By default, GTK+ picks the 
  487.    --  best invisible char available in the current font. If you set the 
  488.    --  invisible char to 0, then the user will get no feedback at all; there 
  489.    --  will be no text on the screen as they type. 
  490.    --  "Char": a Unicode character 
  491.  
  492.    function Get_Layout 
  493.       (The_Entry : not null access Gtk_Entry_Record) 
  494.        return Pango.Layout.Pango_Layout; 
  495.    --  Gets the Pango.Layout.Pango_Layout used to display the entry. The 
  496.    --  layout is useful to e.g. convert text positions to pixel positions, in 
  497.    --  combination with Gtk.GEntry.Get_Layout_Offsets. The returned layout is 
  498.    --  owned by the entry and must not be modified or freed by the caller. 
  499.    --  Keep in mind that the layout text may contain a preedit string, so 
  500.    --  Gtk.GEntry.Layout_Index_To_Text_Index and 
  501.    --  Gtk.GEntry.Text_Index_To_Layout_Index are needed to convert byte indices 
  502.    --  in the layout to byte indices in the entry contents. 
  503.  
  504.    procedure Get_Layout_Offsets 
  505.       (The_Entry : not null access Gtk_Entry_Record; 
  506.        X         : out Gint; 
  507.        Y         : out Gint); 
  508.    --  Obtains the position of the Pango.Layout.Pango_Layout used to render 
  509.    --  text in the entry, in widget coordinates. Useful if you want to line up 
  510.    --  the text in an entry with some other text, e.g. when using the entry to 
  511.    --  implement editable cells in a sheet widget. 
  512.    --  Also useful to convert mouse events into coordinates inside the 
  513.    --  Pango.Layout.Pango_Layout, e.g. to take some action if some part of the 
  514.    --  entry text is clicked. 
  515.    --  Note that as the user scrolls around in the entry the offsets will 
  516.    --  change; you'll need to connect to the "notify::scroll-offset" signal to 
  517.    --  track this. Remember when using the Pango.Layout.Pango_Layout functions 
  518.    --  you need to convert to and from pixels using PANGO_PIXELS or 
  519.    --  PANGO_SCALE. 
  520.    --  Keep in mind that the layout text may contain a preedit string, so 
  521.    --  Gtk.GEntry.Layout_Index_To_Text_Index and 
  522.    --  Gtk.GEntry.Text_Index_To_Layout_Index are needed to convert byte indices 
  523.    --  in the layout to byte indices in the entry contents. 
  524.    --  "x": location to store X offset of layout, or null 
  525.    --  "y": location to store Y offset of layout, or null 
  526.  
  527.    function Get_Max_Length 
  528.       (The_Entry : not null access Gtk_Entry_Record) return Gint; 
  529.    --  Retrieves the maximum allowed length of the text in Entry. See 
  530.    --  Gtk.GEntry.Set_Max_Length. 
  531.    --  This is equivalent to: 
  532.    --    gtk_entry_buffer_get_max_length (gtk_entry_get_buffer (entry)); 
  533.  
  534.    procedure Set_Max_Length 
  535.       (The_Entry : not null access Gtk_Entry_Record; 
  536.        Max       : Gint); 
  537.    --  Sets the maximum allowed length of the contents of the widget. If the 
  538.    --  current contents are longer than the given length, then they will be 
  539.    --  truncated to fit. 
  540.    --  This is equivalent to: 
  541.    --    gtk_entry_buffer_set_max_length (gtk_entry_get_buffer (entry), max); 
  542.    --  "max": the maximum length of the entry, or 0 for no maximum. (other 
  543.    --  than the maximum length of entries.) The value passed in will be clamped 
  544.    --  to the range 0-65536. 
  545.  
  546.    function Get_Overwrite_Mode 
  547.       (The_Entry : not null access Gtk_Entry_Record) return Boolean; 
  548.    --  Gets the value set by Gtk.GEntry.Set_Overwrite_Mode. 
  549.    --  Since: gtk+ 2.14 
  550.  
  551.    procedure Set_Overwrite_Mode 
  552.       (The_Entry : not null access Gtk_Entry_Record; 
  553.        Overwrite : Boolean); 
  554.    --  Sets whether the text is overwritten when typing in the 
  555.    --  Gtk.GEntry.Gtk_Entry. 
  556.    --  Since: gtk+ 2.14 
  557.    --  "overwrite": new value 
  558.  
  559.    function Get_Placeholder_Text 
  560.       (The_Entry : not null access Gtk_Entry_Record) return UTF8_String; 
  561.    --  Retrieves the text that will be displayed when Entry is empty and 
  562.    --  unfocused 
  563.    --  Since: gtk+ 3.2 
  564.  
  565.    procedure Set_Placeholder_Text 
  566.       (The_Entry : not null access Gtk_Entry_Record; 
  567.        Text      : UTF8_String); 
  568.    --  Sets text to be displayed in Entry when it is empty and unfocused. This 
  569.    --  can be used to give a visual hint of the expected contents of the 
  570.    --  Gtk.GEntry.Gtk_Entry. 
  571.    --  Note that since the placeholder text gets removed when the entry 
  572.    --  received focus, using this feature is a bit problematic if the entry is 
  573.    --  given the initial focus in a window. Sometimes this can be worked around 
  574.    --  by delaying the initial focus setting until the first key event arrives. 
  575.    --  Since: gtk+ 3.2 
  576.    --  "text": a string to be displayed when Entry is empty an unfocused, or 
  577.    --  null 
  578.  
  579.    function Get_Progress_Fraction 
  580.       (The_Entry : not null access Gtk_Entry_Record) return Gdouble; 
  581.    --  Returns the current fraction of the task that's been completed. See 
  582.    --  Gtk.GEntry.Set_Progress_Fraction. 
  583.    --  Since: gtk+ 2.16 
  584.  
  585.    procedure Set_Progress_Fraction 
  586.       (The_Entry : not null access Gtk_Entry_Record; 
  587.        Fraction  : Gdouble); 
  588.    --  Causes the entry's progress indicator to "fill in" the given fraction 
  589.    --  of the bar. The fraction should be between 0.0 and 1.0, inclusive. 
  590.    --  Since: gtk+ 2.16 
  591.    --  "fraction": fraction of the task that's been completed 
  592.  
  593.    function Get_Progress_Pulse_Step 
  594.       (The_Entry : not null access Gtk_Entry_Record) return Gdouble; 
  595.    --  Retrieves the pulse step set with Gtk.GEntry.Set_Progress_Pulse_Step. 
  596.    --  Since: gtk+ 2.16 
  597.  
  598.    procedure Set_Progress_Pulse_Step 
  599.       (The_Entry : not null access Gtk_Entry_Record; 
  600.        Fraction  : Gdouble); 
  601.    --  Sets the fraction of total entry width to move the progress bouncing 
  602.    --  block for each call to Gtk.GEntry.Progress_Pulse. 
  603.    --  Since: gtk+ 2.16 
  604.    --  "fraction": fraction between 0.0 and 1.0 
  605.  
  606.    function Get_Text 
  607.       (The_Entry : not null access Gtk_Entry_Record) return UTF8_String; 
  608.    --  Retrieves the contents of the entry widget. See also 
  609.    --  Gtk.Editable.Get_Chars. 
  610.    --  This is equivalent to: 
  611.    --    gtk_entry_buffer_get_text (gtk_entry_get_buffer (entry)); 
  612.  
  613.    procedure Set_Text 
  614.       (The_Entry : not null access Gtk_Entry_Record; 
  615.        Text      : UTF8_String); 
  616.    --  Sets the text in the widget to the given value, replacing the current 
  617.    --  contents. 
  618.    --  See Gtk.Entry_Buffer.Set_Text. 
  619.    --  "text": the new text 
  620.  
  621.    procedure Get_Text_Area 
  622.       (The_Entry : not null access Gtk_Entry_Record; 
  623.        Text_Area : out Gdk.Rectangle.Gdk_Rectangle); 
  624.    --  Gets the area where the entry's text is drawn. This function is useful 
  625.    --  when drawing something to the entry in a draw callback. 
  626.    --  If the entry is not realized, Text_Area is filled with zeros. 
  627.    --  See also Gtk.GEntry.Get_Icon_Area. 
  628.    --  Since: gtk+ 3.0 
  629.    --  "text_area": Return location for the text area. 
  630.  
  631.    function Get_Text_Length 
  632.       (The_Entry : not null access Gtk_Entry_Record) return Guint16; 
  633.    --  Retrieves the current length of the text in Entry. 
  634.    --  This is equivalent to: 
  635.    --    gtk_entry_buffer_get_length (gtk_entry_get_buffer (entry)); 
  636.    --  Since: gtk+ 2.14 
  637.  
  638.    function Get_Visibility 
  639.       (The_Entry : not null access Gtk_Entry_Record) return Boolean; 
  640.    --  Retrieves whether the text in Entry is visible. See 
  641.    --  Gtk.GEntry.Set_Visibility. 
  642.  
  643.    procedure Set_Visibility 
  644.       (The_Entry : not null access Gtk_Entry_Record; 
  645.        Visible   : Boolean); 
  646.    --  Sets whether the contents of the entry are visible or not. When 
  647.    --  visibility is set to False, characters are displayed as the invisible 
  648.    --  char, and will also appear that way when the text in the entry widget is 
  649.    --  copied elsewhere. 
  650.    --  By default, GTK+ picks the best invisible character available in the 
  651.    --  current font, but it can be changed with Gtk.GEntry.Set_Invisible_Char. 
  652.    --  Note that you probably want to set Gtk.GEntry.Gtk_Entry:input-purpose 
  653.    --  to Gtk.Enums.Input_Purpose_Password or Gtk.Enums.Input_Purpose_Pin to 
  654.    --  inform input methods about the purpose of this entry, in addition to 
  655.    --  setting visibility to False. 
  656.    --  "visible": True if the contents of the entry are displayed as plaintext 
  657.  
  658.    function Get_Width_Chars 
  659.       (The_Entry : not null access Gtk_Entry_Record) return Gint; 
  660.    --  Gets the value set by Gtk.GEntry.Set_Width_Chars. 
  661.  
  662.    procedure Set_Width_Chars 
  663.       (The_Entry : not null access Gtk_Entry_Record; 
  664.        Width     : Gint); 
  665.    --  Changes the size request of the entry to be about the right size for 
  666.    --  N_Chars characters. Note that it changes the size *request*, the size 
  667.    --  can still be affected by how you pack the widget into containers. If 
  668.    --  N_Chars is -1, the size reverts to the default entry size. 
  669.    --  "Width": width in chars 
  670.  
  671.    function Im_Context_Filter_Keypress 
  672.       (The_Entry : not null access Gtk_Entry_Record; 
  673.        Event     : Gdk.Event.Gdk_Event_Key) return Boolean; 
  674.    --  Allow the Gtk.GEntry.Gtk_Entry input method to internally handle key 
  675.    --  press and release events. If this function returns True, then no further 
  676.    --  processing should be done for this key event. See 
  677.    --  Gtk.IM_Context.Filter_Keypress. 
  678.    --  Note that you are expected to call this function from your handler when 
  679.    --  overriding key event handling. This is needed in the case when you need 
  680.    --  to insert your own key handling between the input method and the default 
  681.    --  key event handling of the Gtk.GEntry.Gtk_Entry. See 
  682.    --  Gtk.Text_View.Reset_Im_Context for an example of use. 
  683.    --  Since: gtk+ 2.22 
  684.    --  "event": the key event 
  685.  
  686.    function Layout_Index_To_Text_Index 
  687.       (The_Entry    : not null access Gtk_Entry_Record; 
  688.        Layout_Index : Gint) return Gint; 
  689.    --  Converts from a position in the entry contents (returned by 
  690.    --  Gtk.GEntry.Get_Text) to a position in the entry's 
  691.    --  Pango.Layout.Pango_Layout (returned by Gtk.GEntry.Get_Layout, with text 
  692.    --  retrieved via Pango.Layout.Get_Text). 
  693.    --  "layout_index": byte index into the entry layout text 
  694.  
  695.    procedure Progress_Pulse (The_Entry : not null access Gtk_Entry_Record); 
  696.    --  Indicates that some progress is made, but you don't know how much. 
  697.    --  Causes the entry's progress indicator to enter "activity mode," where a 
  698.    --  block bounces back and forth. Each call to Gtk.GEntry.Progress_Pulse 
  699.    --  causes the block to move by a little bit (the amount of movement per 
  700.    --  pulse is determined by Gtk.GEntry.Set_Progress_Pulse_Step). 
  701.    --  Since: gtk+ 2.16 
  702.  
  703.    procedure Reset_Im_Context (The_Entry : not null access Gtk_Entry_Record); 
  704.    --  Reset the input method context of the entry if needed. 
  705.    --  This can be necessary in the case where modifying the buffer would 
  706.    --  confuse on-going input method behavior. 
  707.    --  Since: gtk+ 2.22 
  708.  
  709.    procedure Set_Icon_Drag_Source 
  710.       (The_Entry   : not null access Gtk_Entry_Record; 
  711.        Icon_Pos    : Gtk_Entry_Icon_Position; 
  712.        Target_List : Gtk.Target_List.Gtk_Target_List; 
  713.        Actions     : Gdk.Drag_Contexts.Gdk_Drag_Action); 
  714.    --  Sets up the icon at the given position so that GTK+ will start a drag 
  715.    --  operation when the user clicks and drags the icon. 
  716.    --  To handle the drag operation, you need to connect to the usual 
  717.    --  Gtk.Widget.Gtk_Widget::drag-data-get (or possibly 
  718.    --  Gtk.Widget.Gtk_Widget::drag-data-delete) signal, and use 
  719.    --  Gtk.GEntry.Get_Current_Icon_Drag_Source in your signal handler to find 
  720.    --  out if the drag was started from an icon. 
  721.    --  By default, GTK+ uses the icon as the drag icon. You can use the 
  722.    --  Gtk.Widget.Gtk_Widget::drag-begin signal to set a different icon. Note 
  723.    --  that you have to use g_signal_connect_after to ensure that your signal 
  724.    --  handler gets executed after the default handler. 
  725.    --  Since: gtk+ 2.16 
  726.    --  "icon_pos": icon position 
  727.    --  "target_list": the targets (data formats) in which the data can be 
  728.    --  provided 
  729.    --  "actions": a bitmask of the allowed drag actions 
  730.  
  731.    procedure Set_Icon_From_Gicon 
  732.       (The_Entry : not null access Gtk_Entry_Record; 
  733.        Icon_Pos  : Gtk_Entry_Icon_Position; 
  734.        Icon      : Glib.G_Icon.G_Icon); 
  735.    --  Sets the icon shown in the entry at the specified position from the 
  736.    --  current icon theme. If the icon isn't known, a "broken image" icon will 
  737.    --  be displayed instead. 
  738.    --  If Icon is null, no icon will be shown in the specified position. 
  739.    --  Since: gtk+ 2.16 
  740.    --  "icon_pos": The position at which to set the icon 
  741.    --  "icon": The icon to set, or null 
  742.  
  743.    procedure Set_Icon_From_Icon_Name 
  744.       (The_Entry : not null access Gtk_Entry_Record; 
  745.        Icon_Pos  : Gtk_Entry_Icon_Position; 
  746.        Icon_Name : UTF8_String := ""); 
  747.    --  Sets the icon shown in the entry at the specified position from the 
  748.    --  current icon theme. 
  749.    --  If the icon name isn't known, a "broken image" icon will be displayed 
  750.    --  instead. 
  751.    --  If Icon_Name is null, no icon will be shown in the specified position. 
  752.    --  Since: gtk+ 2.16 
  753.    --  "icon_pos": The position at which to set the icon 
  754.    --  "icon_name": An icon name, or null 
  755.  
  756.    procedure Set_Icon_From_Pixbuf 
  757.       (The_Entry : not null access Gtk_Entry_Record; 
  758.        Icon_Pos  : Gtk_Entry_Icon_Position; 
  759.        Pixbuf    : access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class); 
  760.    --  Sets the icon shown in the specified position using a pixbuf. 
  761.    --  If Pixbuf is null, no icon will be shown in the specified position. 
  762.    --  Since: gtk+ 2.16 
  763.    --  "icon_pos": Icon position 
  764.    --  "pixbuf": A Gdk.Pixbuf.Gdk_Pixbuf, or null 
  765.  
  766.    procedure Set_Icon_From_Stock 
  767.       (The_Entry : not null access Gtk_Entry_Record; 
  768.        Icon_Pos  : Gtk_Entry_Icon_Position; 
  769.        Stock_Id  : UTF8_String := ""); 
  770.    --  Sets the icon shown in the entry at the specified position from a stock 
  771.    --  image. 
  772.    --  If Stock_Id is null, no icon will be shown in the specified position. 
  773.    --  Since: gtk+ 2.16 
  774.    --  "icon_pos": Icon position 
  775.    --  "stock_id": The name of the stock item, or null 
  776.  
  777.    function Text_Index_To_Layout_Index 
  778.       (The_Entry  : not null access Gtk_Entry_Record; 
  779.        Text_Index : Gint) return Gint; 
  780.    --  Converts from a position in the entry's Pango.Layout.Pango_Layout 
  781.    --  (returned by Gtk.GEntry.Get_Layout) to a position in the entry contents 
  782.    --  (returned by Gtk.GEntry.Get_Text). 
  783.    --  "text_index": byte index into the entry contents 
  784.  
  785.    procedure Unset_Invisible_Char 
  786.       (The_Entry : not null access Gtk_Entry_Record); 
  787.    --  Unsets the invisible char previously set with 
  788.    --  Gtk.GEntry.Set_Invisible_Char. So that the default invisible char is 
  789.    --  used again. 
  790.    --  Since: gtk+ 2.16 
  791.  
  792.    ---------------------- 
  793.    -- GtkAda additions -- 
  794.    ---------------------- 
  795.  
  796.    subtype Gtk_GEntry is Gtk_Entry; 
  797.  
  798.    procedure Insert_Text 
  799.      (Editable : access Gtk_Entry_Record; 
  800.       New_Text : UTF8_String; 
  801.       Position : in out Gint); 
  802.    --  Convenience subprogram, identical to Insert_Text above without 
  803.    --  the requirement to supply the New_Text_Length argument. 
  804.  
  805.    --------------------------------------------- 
  806.    -- Inherited subprograms (from interfaces) -- 
  807.    --------------------------------------------- 
  808.    --  Methods inherited from the Buildable interface are not duplicated here 
  809.    --  since they are meant to be used by tools, mostly. If you need to call 
  810.    --  them, use an explicit cast through the "-" operator below. 
  811.  
  812.    procedure Editing_Done (Cell_Editable : not null access Gtk_Entry_Record); 
  813.  
  814.    procedure Remove_Widget 
  815.       (Cell_Editable : not null access Gtk_Entry_Record); 
  816.  
  817.    procedure Start_Editing 
  818.       (Cell_Editable : not null access Gtk_Entry_Record; 
  819.        Event         : Gdk.Event.Gdk_Event); 
  820.  
  821.    procedure Copy_Clipboard (Editable : not null access Gtk_Entry_Record); 
  822.  
  823.    procedure Cut_Clipboard (Editable : not null access Gtk_Entry_Record); 
  824.  
  825.    procedure Delete_Selection (Editable : not null access Gtk_Entry_Record); 
  826.  
  827.    procedure Delete_Text 
  828.       (Editable  : not null access Gtk_Entry_Record; 
  829.        Start_Pos : Gint; 
  830.        End_Pos   : Gint := -1); 
  831.  
  832.    function Get_Chars 
  833.       (Editable  : not null access Gtk_Entry_Record; 
  834.        Start_Pos : Gint; 
  835.        End_Pos   : Gint := -1) return UTF8_String; 
  836.  
  837.    function Get_Editable 
  838.       (Editable : not null access Gtk_Entry_Record) return Boolean; 
  839.  
  840.    procedure Set_Editable 
  841.       (Editable    : not null access Gtk_Entry_Record; 
  842.        Is_Editable : Boolean); 
  843.  
  844.    function Get_Position 
  845.       (Editable : not null access Gtk_Entry_Record) return Gint; 
  846.  
  847.    procedure Set_Position 
  848.       (Editable : not null access Gtk_Entry_Record; 
  849.        Position : Gint); 
  850.  
  851.    procedure Get_Selection_Bounds 
  852.       (Editable      : not null access Gtk_Entry_Record; 
  853.        Start_Pos     : out Gint; 
  854.        End_Pos       : out Gint; 
  855.        Has_Selection : out Boolean); 
  856.  
  857.    procedure Insert_Text 
  858.       (Editable        : not null access Gtk_Entry_Record; 
  859.        New_Text        : UTF8_String; 
  860.        New_Text_Length : Gint; 
  861.        Position        : in out Gint); 
  862.  
  863.    procedure Paste_Clipboard (Editable : not null access Gtk_Entry_Record); 
  864.  
  865.    procedure Select_Region 
  866.       (Editable  : not null access Gtk_Entry_Record; 
  867.        Start_Pos : Gint; 
  868.        End_Pos   : Gint := -1); 
  869.  
  870.    ---------------- 
  871.    -- Properties -- 
  872.    ---------------- 
  873.    --  The following properties are defined for this widget. See 
  874.    --  Glib.Properties for more information on properties) 
  875.  
  876.    Activates_Default_Property : constant Glib.Properties.Property_Boolean; 
  877.  
  878.    Attributes_Property : constant Glib.Properties.Property_Object; 
  879.    --  Type: Pango.Attributes.Pango_Attr_List 
  880.    --  A list of Pango attributes to apply to the text of the entry. 
  881.    -- 
  882.    --  This is mainly useful to change the size or weight of the text. 
  883.  
  884.    Buffer_Property : constant Glib.Properties.Property_Object; 
  885.    --  Type: Gtk.Entry_Buffer.Gtk_Entry_Buffer 
  886.  
  887.    Caps_Lock_Warning_Property : constant Glib.Properties.Property_Boolean; 
  888.    --  Whether password entries will show a warning when Caps Lock is on. 
  889.    -- 
  890.    --  Note that the warning is shown using a secondary icon, and thus does 
  891.    --  not work if you are using the secondary icon position for some other 
  892.    --  purpose. 
  893.  
  894.    Completion_Property : constant Glib.Properties.Property_Object; 
  895.    --  Type: Gtk.Entry_Completion.Gtk_Entry_Completion 
  896.    --  The auxiliary completion object to use with the entry. 
  897.  
  898.    Cursor_Position_Property : constant Glib.Properties.Property_Int; 
  899.  
  900.    Editable_Property : constant Glib.Properties.Property_Boolean; 
  901.  
  902.    Has_Frame_Property : constant Glib.Properties.Property_Boolean; 
  903.  
  904.    Im_Module_Property : constant Glib.Properties.Property_String; 
  905.    --  Which IM (input method) module should be used for this entry. See 
  906.    --  Gtk.IM_Context.Gtk_IM_Context. 
  907.    -- 
  908.    --  Setting this to a non-null value overrides the system-wide IM module 
  909.    --  setting. See the GtkSettings Gtk.Settings.Gtk_Settings:gtk-im-module 
  910.    --  property. 
  911.  
  912.    Inner_Border_Property : constant Glib.Properties.Property_Boxed; 
  913.    --  Type: Gtk.Style.Gtk_Border 
  914.    --  Sets the text area's border between the text and the frame. 
  915.  
  916.    Input_Hints_Property : constant Gtk.Enums.Property_Gtk_Input_Hints; 
  917.    --  Additional hints (beyond Gtk.GEntry.Gtk_Entry:input-purpose) that allow 
  918.    --  input methods to fine-tune their behaviour. 
  919.  
  920.    Input_Purpose_Property : constant Gtk.Enums.Property_Gtk_Input_Purpose; 
  921.    --  The purpose of this text field. 
  922.    -- 
  923.    --  This property can be used by on-screen keyboards and other input 
  924.    --  methods to adjust their behaviour. 
  925.    -- 
  926.    --  Note that setting the purpose to Gtk.Enums.Input_Purpose_Password or 
  927.    --  Gtk.Enums.Input_Purpose_Pin is independent from setting 
  928.    --  Gtk.GEntry.Gtk_Entry:visibility. 
  929.  
  930.    Invisible_Char_Property : constant Glib.Properties.Property_Uint; 
  931.    --  The invisible character is used when masking entry contents (in 
  932.    --  \"password mode\")"). When it is not explicitly set with the 
  933.    --  Gtk.GEntry.Gtk_Entry:invisible-char property, GTK+ determines the 
  934.    --  character to use from a list of possible candidates, depending on 
  935.    --  availability in the current font. 
  936.    -- 
  937.    --  This style property allows the theme to prepend a character to the list 
  938.    --  of candidates. 
  939.  
  940.    Invisible_Char_Set_Property : constant Glib.Properties.Property_Boolean; 
  941.    --  Whether the invisible char has been set for the Gtk.GEntry.Gtk_Entry. 
  942.  
  943.    Max_Length_Property : constant Glib.Properties.Property_Int; 
  944.  
  945.    Overwrite_Mode_Property : constant Glib.Properties.Property_Boolean; 
  946.    --  If text is overwritten when typing in the Gtk.GEntry.Gtk_Entry. 
  947.  
  948.    Placeholder_Text_Property : constant Glib.Properties.Property_String; 
  949.    --  The text that will be displayed in the Gtk.GEntry.Gtk_Entry when it is 
  950.    --  empty and unfocused. 
  951.  
  952.    Populate_All_Property : constant Glib.Properties.Property_Boolean; 
  953.  
  954.    Primary_Icon_Activatable_Property : constant Glib.Properties.Property_Boolean; 
  955.    --  Whether the primary icon is activatable. 
  956.    -- 
  957.    --  GTK+ emits the Gtk.GEntry.Gtk_Entry::icon-press and 
  958.    --  Gtk.GEntry.Gtk_Entry::icon-release signals only on sensitive, 
  959.    --  activatable icons. 
  960.    -- 
  961.    --  Sensitive, but non-activatable icons can be used for purely 
  962.    --  informational purposes. 
  963.  
  964.    Primary_Icon_Gicon_Property : constant Glib.Properties.Property_Boxed; 
  965.    --  Type: Glib.G_Icon.G_Icon 
  966.    --  The Glib.G_Icon.G_Icon to use for the primary icon for the entry. 
  967.  
  968.    Primary_Icon_Name_Property : constant Glib.Properties.Property_String; 
  969.    --  The icon name to use for the primary icon for the entry. 
  970.  
  971.    Primary_Icon_Pixbuf_Property : constant Glib.Properties.Property_Object; 
  972.    --  Type: Gdk.Pixbuf.Gdk_Pixbuf 
  973.    --  A pixbuf to use as the primary icon for the entry. 
  974.  
  975.    Primary_Icon_Sensitive_Property : constant Glib.Properties.Property_Boolean; 
  976.    --  Whether the primary icon is sensitive. 
  977.    -- 
  978.    --  An insensitive icon appears grayed out. GTK+ does not emit the 
  979.    --  Gtk.GEntry.Gtk_Entry::icon-press and Gtk.GEntry.Gtk_Entry::icon-release 
  980.    --  signals and does not allow DND from insensitive icons. 
  981.    -- 
  982.    --  An icon should be set insensitive if the action that would trigger when 
  983.    --  clicked is currently not available. 
  984.  
  985.    Primary_Icon_Stock_Property : constant Glib.Properties.Property_String; 
  986.    --  The stock id to use for the primary icon for the entry. 
  987.  
  988.    Primary_Icon_Storage_Type_Property : constant Gtk.Image.Property_Gtk_Image_Type; 
  989.    --  Type: Gtk.Image.Gtk_Image_Type 
  990.    --  The representation which is used for the primary icon of the entry. 
  991.  
  992.    Primary_Icon_Tooltip_Markup_Property : constant Glib.Properties.Property_String; 
  993.    --  The contents of the tooltip on the primary icon, which is marked up 
  994.    --  with the <link linkend="PangoMarkupFormat">Pango text markup 
  995.    --  language</link>. 
  996.    -- 
  997.    --  Also see Gtk.GEntry.Set_Icon_Tooltip_Markup. 
  998.  
  999.    Primary_Icon_Tooltip_Text_Property : constant Glib.Properties.Property_String; 
  1000.    --  The contents of the tooltip on the primary icon. 
  1001.    -- 
  1002.    --  Also see Gtk.GEntry.Set_Icon_Tooltip_Text. 
  1003.  
  1004.    Progress_Fraction_Property : constant Glib.Properties.Property_Double; 
  1005.    --  Type: Gdouble 
  1006.    --  The current fraction of the task that's been completed. 
  1007.  
  1008.    Progress_Pulse_Step_Property : constant Glib.Properties.Property_Double; 
  1009.    --  Type: Gdouble 
  1010.    --  The fraction of total entry width to move the progress bouncing block 
  1011.    --  for each call to Gtk.GEntry.Progress_Pulse. 
  1012.  
  1013.    Scroll_Offset_Property : constant Glib.Properties.Property_Int; 
  1014.  
  1015.    Secondary_Icon_Activatable_Property : constant Glib.Properties.Property_Boolean; 
  1016.    --  Whether the secondary icon is activatable. 
  1017.    -- 
  1018.    --  GTK+ emits the Gtk.GEntry.Gtk_Entry::icon-press and 
  1019.    --  Gtk.GEntry.Gtk_Entry::icon-release signals only on sensitive, 
  1020.    --  activatable icons. 
  1021.    -- 
  1022.    --  Sensitive, but non-activatable icons can be used for purely 
  1023.    --  informational purposes. 
  1024.  
  1025.    Secondary_Icon_Gicon_Property : constant Glib.Properties.Property_Boxed; 
  1026.    --  Type: Glib.G_Icon.G_Icon 
  1027.    --  The Glib.G_Icon.G_Icon to use for the secondary icon for the entry. 
  1028.  
  1029.    Secondary_Icon_Name_Property : constant Glib.Properties.Property_String; 
  1030.    --  The icon name to use for the secondary icon for the entry. 
  1031.  
  1032.    Secondary_Icon_Pixbuf_Property : constant Glib.Properties.Property_Object; 
  1033.    --  Type: Gdk.Pixbuf.Gdk_Pixbuf 
  1034.    --  An pixbuf to use as the secondary icon for the entry. 
  1035.  
  1036.    Secondary_Icon_Sensitive_Property : constant Glib.Properties.Property_Boolean; 
  1037.    --  Whether the secondary icon is sensitive. 
  1038.    -- 
  1039.    --  An insensitive icon appears grayed out. GTK+ does not emit the 
  1040.    --  Gtk.GEntry.Gtk_Entry::icon-press and Gtk.GEntry.Gtk_Entry::icon-release 
  1041.    --  signals and does not allow DND from insensitive icons. 
  1042.    -- 
  1043.    --  An icon should be set insensitive if the action that would trigger when 
  1044.    --  clicked is currently not available. 
  1045.  
  1046.    Secondary_Icon_Stock_Property : constant Glib.Properties.Property_String; 
  1047.    --  The stock id to use for the secondary icon for the entry. 
  1048.  
  1049.    Secondary_Icon_Storage_Type_Property : constant Gtk.Image.Property_Gtk_Image_Type; 
  1050.    --  Type: Gtk.Image.Gtk_Image_Type 
  1051.    --  The representation which is used for the secondary icon of the entry. 
  1052.  
  1053.    Secondary_Icon_Tooltip_Markup_Property : constant Glib.Properties.Property_String; 
  1054.    --  The contents of the tooltip on the secondary icon, which is marked up 
  1055.    --  with the <link linkend="PangoMarkupFormat">Pango text markup 
  1056.    --  language</link>. 
  1057.    -- 
  1058.    --  Also see Gtk.GEntry.Set_Icon_Tooltip_Markup. 
  1059.  
  1060.    Secondary_Icon_Tooltip_Text_Property : constant Glib.Properties.Property_String; 
  1061.    --  The contents of the tooltip on the secondary icon. 
  1062.    -- 
  1063.    --  Also see Gtk.GEntry.Set_Icon_Tooltip_Text. 
  1064.  
  1065.    Selection_Bound_Property : constant Glib.Properties.Property_Int; 
  1066.  
  1067.    Shadow_Type_Property : constant Gtk.Enums.Property_Gtk_Shadow_Type; 
  1068.    --  Which kind of shadow to draw around the entry when 
  1069.    --  Gtk.GEntry.Gtk_Entry:has-frame is set to True. 
  1070.  
  1071.    Text_Property : constant Glib.Properties.Property_String; 
  1072.  
  1073.    Text_Length_Property : constant Glib.Properties.Property_Uint; 
  1074.    --  The length of the text in the Gtk.GEntry.Gtk_Entry. 
  1075.  
  1076.    Truncate_Multiline_Property : constant Glib.Properties.Property_Boolean; 
  1077.    --  When True, pasted multi-line text is truncated to the first line. 
  1078.  
  1079.    Visibility_Property : constant Glib.Properties.Property_Boolean; 
  1080.  
  1081.    Width_Chars_Property : constant Glib.Properties.Property_Int; 
  1082.  
  1083.    Xalign_Property : constant Glib.Properties.Property_Float; 
  1084.    --  The horizontal alignment, from 0 (left) to 1 (right). Reversed for RTL 
  1085.    --  layouts. 
  1086.  
  1087.    ------------- 
  1088.    -- Signals -- 
  1089.    ------------- 
  1090.  
  1091.    type Cb_Gtk_Entry_Void is not null access procedure (Self : access Gtk_Entry_Record'Class); 
  1092.  
  1093.    type Cb_GObject_Void is not null access procedure 
  1094.      (Self : access Glib.Object.GObject_Record'Class); 
  1095.  
  1096.    Signal_Activate : constant Glib.Signal_Name := "activate"; 
  1097.    procedure On_Activate 
  1098.       (Self  : not null access Gtk_Entry_Record; 
  1099.        Call  : Cb_Gtk_Entry_Void; 
  1100.        After : Boolean := False); 
  1101.    procedure On_Activate 
  1102.       (Self  : not null access Gtk_Entry_Record; 
  1103.        Call  : Cb_GObject_Void; 
  1104.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1105.        After : Boolean := False); 
  1106.    --  The ::activate signal is emitted when the user hits the Enter key. 
  1107.    -- 
  1108.    --  While this signal is used as a <link 
  1109.    --  linkend="keybinding-signals">keybinding signal</link>, it is also 
  1110.    --  commonly used by applications to intercept activation of entries. 
  1111.    -- 
  1112.    --  The default bindings for this signal are all forms of the Enter key. 
  1113.  
  1114.    Signal_Backspace : constant Glib.Signal_Name := "backspace"; 
  1115.    procedure On_Backspace 
  1116.       (Self  : not null access Gtk_Entry_Record; 
  1117.        Call  : Cb_Gtk_Entry_Void; 
  1118.        After : Boolean := False); 
  1119.    procedure On_Backspace 
  1120.       (Self  : not null access Gtk_Entry_Record; 
  1121.        Call  : Cb_GObject_Void; 
  1122.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1123.        After : Boolean := False); 
  1124.    --  The ::backspace signal is a <link 
  1125.    --  linkend="keybinding-signals">keybinding signal</link> which gets emitted 
  1126.    --  when the user asks for it. 
  1127.    -- 
  1128.    --  The default bindings for this signal are Backspace and Shift-Backspace. 
  1129.  
  1130.    Signal_Copy_Clipboard : constant Glib.Signal_Name := "copy-clipboard"; 
  1131.    procedure On_Copy_Clipboard 
  1132.       (Self  : not null access Gtk_Entry_Record; 
  1133.        Call  : Cb_Gtk_Entry_Void; 
  1134.        After : Boolean := False); 
  1135.    procedure On_Copy_Clipboard 
  1136.       (Self  : not null access Gtk_Entry_Record; 
  1137.        Call  : Cb_GObject_Void; 
  1138.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1139.        After : Boolean := False); 
  1140.    --  The ::copy-clipboard signal is a <link 
  1141.    --  linkend="keybinding-signals">keybinding signal</link> which gets emitted 
  1142.    --  to copy the selection to the clipboard. 
  1143.    -- 
  1144.    --  The default bindings for this signal are Ctrl-c and Ctrl-Insert. 
  1145.  
  1146.    Signal_Cut_Clipboard : constant Glib.Signal_Name := "cut-clipboard"; 
  1147.    procedure On_Cut_Clipboard 
  1148.       (Self  : not null access Gtk_Entry_Record; 
  1149.        Call  : Cb_Gtk_Entry_Void; 
  1150.        After : Boolean := False); 
  1151.    procedure On_Cut_Clipboard 
  1152.       (Self  : not null access Gtk_Entry_Record; 
  1153.        Call  : Cb_GObject_Void; 
  1154.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1155.        After : Boolean := False); 
  1156.    --  The ::cut-clipboard signal is a <link 
  1157.    --  linkend="keybinding-signals">keybinding signal</link> which gets emitted 
  1158.    --  to cut the selection to the clipboard. 
  1159.    -- 
  1160.    --  The default bindings for this signal are Ctrl-x and Shift-Delete. 
  1161.  
  1162.    type Cb_Gtk_Entry_Gtk_Delete_Type_Gint_Void is not null access procedure 
  1163.      (Self     : access Gtk_Entry_Record'Class; 
  1164.       The_Type : Gtk.Enums.Gtk_Delete_Type; 
  1165.       Count    : Gint); 
  1166.  
  1167.    type Cb_GObject_Gtk_Delete_Type_Gint_Void is not null access procedure 
  1168.      (Self     : access Glib.Object.GObject_Record'Class; 
  1169.       The_Type : Gtk.Enums.Gtk_Delete_Type; 
  1170.       Count    : Gint); 
  1171.  
  1172.    Signal_Delete_From_Cursor : constant Glib.Signal_Name := "delete-from-cursor"; 
  1173.    procedure On_Delete_From_Cursor 
  1174.       (Self  : not null access Gtk_Entry_Record; 
  1175.        Call  : Cb_Gtk_Entry_Gtk_Delete_Type_Gint_Void; 
  1176.        After : Boolean := False); 
  1177.    procedure On_Delete_From_Cursor 
  1178.       (Self  : not null access Gtk_Entry_Record; 
  1179.        Call  : Cb_GObject_Gtk_Delete_Type_Gint_Void; 
  1180.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1181.        After : Boolean := False); 
  1182.    --  The ::delete-from-cursor signal is a <link 
  1183.    --  linkend="keybinding-signals">keybinding signal</link> which gets emitted 
  1184.    --  when the user initiates a text deletion. 
  1185.    -- 
  1186.    --  If the Type is Gtk.Enums.Delete_Chars, GTK+ deletes the selection if 
  1187.    --  there is one, otherwise it deletes the requested number of characters. 
  1188.    -- 
  1189.    --  The default bindings for this signal are Delete for deleting a 
  1190.    --  character and Ctrl-Delete for deleting a word. 
  1191.    --  
  1192.    --  Callback parameters: 
  1193.    --    --  "type": the granularity of the deletion, as a Gtk.Enums.Gtk_Delete_Type 
  1194.    --    --  "count": the number of Type units to delete 
  1195.  
  1196.    type Cb_Gtk_Entry_Gtk_Entry_Icon_Position_Gdk_Event_Button_Void is not null access procedure 
  1197.      (Self     : access Gtk_Entry_Record'Class; 
  1198.       Icon_Pos : Gtk_Entry_Icon_Position; 
  1199.       Event    : Gdk.Event.Gdk_Event_Button); 
  1200.  
  1201.    type Cb_GObject_Gtk_Entry_Icon_Position_Gdk_Event_Button_Void is not null access procedure 
  1202.      (Self     : access Glib.Object.GObject_Record'Class; 
  1203.       Icon_Pos : Gtk_Entry_Icon_Position; 
  1204.       Event    : Gdk.Event.Gdk_Event_Button); 
  1205.  
  1206.    Signal_Icon_Press : constant Glib.Signal_Name := "icon-press"; 
  1207.    procedure On_Icon_Press 
  1208.       (Self  : not null access Gtk_Entry_Record; 
  1209.        Call  : Cb_Gtk_Entry_Gtk_Entry_Icon_Position_Gdk_Event_Button_Void; 
  1210.        After : Boolean := False); 
  1211.    procedure On_Icon_Press 
  1212.       (Self  : not null access Gtk_Entry_Record; 
  1213.        Call  : Cb_GObject_Gtk_Entry_Icon_Position_Gdk_Event_Button_Void; 
  1214.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1215.        After : Boolean := False); 
  1216.    --  The ::icon-press signal is emitted when an activatable icon is clicked. 
  1217.    --  
  1218.    --  Callback parameters: 
  1219.    --    --  "icon_pos": The position of the clicked icon 
  1220.    --    --  "event": the button press event 
  1221.  
  1222.    Signal_Icon_Release : constant Glib.Signal_Name := "icon-release"; 
  1223.    procedure On_Icon_Release 
  1224.       (Self  : not null access Gtk_Entry_Record; 
  1225.        Call  : Cb_Gtk_Entry_Gtk_Entry_Icon_Position_Gdk_Event_Button_Void; 
  1226.        After : Boolean := False); 
  1227.    procedure On_Icon_Release 
  1228.       (Self  : not null access Gtk_Entry_Record; 
  1229.        Call  : Cb_GObject_Gtk_Entry_Icon_Position_Gdk_Event_Button_Void; 
  1230.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1231.        After : Boolean := False); 
  1232.    --  The ::icon-release signal is emitted on the button release from a mouse 
  1233.    --  click over an activatable icon. 
  1234.    --  
  1235.    --  Callback parameters: 
  1236.    --    --  "icon_pos": The position of the clicked icon 
  1237.    --    --  "event": the button release event 
  1238.  
  1239.    type Cb_Gtk_Entry_UTF8_String_Void is not null access procedure 
  1240.      (Self   : access Gtk_Entry_Record'Class; 
  1241.       String : UTF8_String); 
  1242.  
  1243.    type Cb_GObject_UTF8_String_Void is not null access procedure 
  1244.      (Self   : access Glib.Object.GObject_Record'Class; 
  1245.       String : UTF8_String); 
  1246.  
  1247.    Signal_Insert_At_Cursor : constant Glib.Signal_Name := "insert-at-cursor"; 
  1248.    procedure On_Insert_At_Cursor 
  1249.       (Self  : not null access Gtk_Entry_Record; 
  1250.        Call  : Cb_Gtk_Entry_UTF8_String_Void; 
  1251.        After : Boolean := False); 
  1252.    procedure On_Insert_At_Cursor 
  1253.       (Self  : not null access Gtk_Entry_Record; 
  1254.        Call  : Cb_GObject_UTF8_String_Void; 
  1255.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1256.        After : Boolean := False); 
  1257.    --  The ::insert-at-cursor signal is a <link 
  1258.    --  linkend="keybinding-signals">keybinding signal</link> which gets emitted 
  1259.    --  when the user initiates the insertion of a fixed string at the cursor. 
  1260.    -- 
  1261.    --  This signal has no default bindings. 
  1262.  
  1263.    type Cb_Gtk_Entry_Gtk_Movement_Step_Gint_Boolean_Void is not null access procedure 
  1264.      (Self             : access Gtk_Entry_Record'Class; 
  1265.       Step             : Gtk.Enums.Gtk_Movement_Step; 
  1266.       Count            : Gint; 
  1267.       Extend_Selection : Boolean); 
  1268.  
  1269.    type Cb_GObject_Gtk_Movement_Step_Gint_Boolean_Void is not null access procedure 
  1270.      (Self             : access Glib.Object.GObject_Record'Class; 
  1271.       Step             : Gtk.Enums.Gtk_Movement_Step; 
  1272.       Count            : Gint; 
  1273.       Extend_Selection : Boolean); 
  1274.  
  1275.    Signal_Move_Cursor : constant Glib.Signal_Name := "move-cursor"; 
  1276.    procedure On_Move_Cursor 
  1277.       (Self  : not null access Gtk_Entry_Record; 
  1278.        Call  : Cb_Gtk_Entry_Gtk_Movement_Step_Gint_Boolean_Void; 
  1279.        After : Boolean := False); 
  1280.    procedure On_Move_Cursor 
  1281.       (Self  : not null access Gtk_Entry_Record; 
  1282.        Call  : Cb_GObject_Gtk_Movement_Step_Gint_Boolean_Void; 
  1283.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1284.        After : Boolean := False); 
  1285.    --  The ::move-cursor signal is a <link 
  1286.    --  linkend="keybinding-signals">keybinding signal</link> which gets emitted 
  1287.    --  when the user initiates a cursor movement. If the cursor is not visible 
  1288.    --  in Entry, this signal causes the viewport to be moved instead. 
  1289.    -- 
  1290.    --  Applications should not connect to it, but may emit it with 
  1291.    --  g_signal_emit_by_name if they need to control the cursor 
  1292.    --  programmatically. 
  1293.    -- 
  1294.    --  The default bindings for this signal come in two variants, the variant 
  1295.    --  with the Shift modifier extends the selection, the variant without the 
  1296.    --  Shift modifer does not. There are too many key combinations to list them 
  1297.    --  all here. 
  1298.    -- 
  1299.    --     * Arrow keys move by individual characters/lines 
  1300.    -- 
  1301.    --     * Ctrl-arrow key combinations move by words/paragraphs 
  1302.    -- 
  1303.    --     * Home/End keys move to the ends of the buffer 
  1304.    --  
  1305.    --  Callback parameters: 
  1306.    --    --  "step": the granularity of the move, as a Gtk.Enums.Gtk_Movement_Step 
  1307.    --    --  "count": the number of Step units to move 
  1308.    --    --  "extend_selection": True if the move should extend the selection 
  1309.  
  1310.    Signal_Paste_Clipboard : constant Glib.Signal_Name := "paste-clipboard"; 
  1311.    procedure On_Paste_Clipboard 
  1312.       (Self  : not null access Gtk_Entry_Record; 
  1313.        Call  : Cb_Gtk_Entry_Void; 
  1314.        After : Boolean := False); 
  1315.    procedure On_Paste_Clipboard 
  1316.       (Self  : not null access Gtk_Entry_Record; 
  1317.        Call  : Cb_GObject_Void; 
  1318.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1319.        After : Boolean := False); 
  1320.    --  The ::paste-clipboard signal is a <link 
  1321.    --  linkend="keybinding-signals">keybinding signal</link> which gets emitted 
  1322.    --  to paste the contents of the clipboard into the text view. 
  1323.    -- 
  1324.    --  The default bindings for this signal are Ctrl-v and Shift-Insert. 
  1325.  
  1326.    type Cb_Gtk_Entry_Gtk_Widget_Void is not null access procedure 
  1327.      (Self  : access Gtk_Entry_Record'Class; 
  1328.       Popup : not null access Gtk.Widget.Gtk_Widget_Record'Class); 
  1329.  
  1330.    type Cb_GObject_Gtk_Widget_Void is not null access procedure 
  1331.      (Self  : access Glib.Object.GObject_Record'Class; 
  1332.       Popup : not null access Gtk.Widget.Gtk_Widget_Record'Class); 
  1333.  
  1334.    Signal_Populate_Popup : constant Glib.Signal_Name := "populate-popup"; 
  1335.    procedure On_Populate_Popup 
  1336.       (Self  : not null access Gtk_Entry_Record; 
  1337.        Call  : Cb_Gtk_Entry_Gtk_Widget_Void; 
  1338.        After : Boolean := False); 
  1339.    procedure On_Populate_Popup 
  1340.       (Self  : not null access Gtk_Entry_Record; 
  1341.        Call  : Cb_GObject_Gtk_Widget_Void; 
  1342.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1343.        After : Boolean := False); 
  1344.    --  The ::populate-popup signal gets emitted before showing the context 
  1345.    --  menu of the entry. 
  1346.    -- 
  1347.    --  If you need to add items to the context menu, connect to this signal 
  1348.    --  and append your items to the Widget, which will be a Gtk.Menu.Gtk_Menu 
  1349.    --  in this case. 
  1350.    -- 
  1351.    --  If Gtk.GEntry.Gtk_Entry::populate-all is True, this signal will also be 
  1352.    --  emitted to populate touch popups. In this case, Widget will be a 
  1353.    --  different container, e.g. a Gtk.Toolbar.Gtk_Toolbar. The signal handler 
  1354.    --  should not make assumptions about the type of Widget. 
  1355.  
  1356.    Signal_Preedit_Changed : constant Glib.Signal_Name := "preedit-changed"; 
  1357.    procedure On_Preedit_Changed 
  1358.       (Self  : not null access Gtk_Entry_Record; 
  1359.        Call  : Cb_Gtk_Entry_UTF8_String_Void; 
  1360.        After : Boolean := False); 
  1361.    procedure On_Preedit_Changed 
  1362.       (Self  : not null access Gtk_Entry_Record; 
  1363.        Call  : Cb_GObject_UTF8_String_Void; 
  1364.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1365.        After : Boolean := False); 
  1366.    --  If an input method is used, the typed text will not immediately be 
  1367.    --  committed to the buffer. So if you are interested in the text, connect 
  1368.    --  to this signal. 
  1369.  
  1370.    Signal_Toggle_Overwrite : constant Glib.Signal_Name := "toggle-overwrite"; 
  1371.    procedure On_Toggle_Overwrite 
  1372.       (Self  : not null access Gtk_Entry_Record; 
  1373.        Call  : Cb_Gtk_Entry_Void; 
  1374.        After : Boolean := False); 
  1375.    procedure On_Toggle_Overwrite 
  1376.       (Self  : not null access Gtk_Entry_Record; 
  1377.        Call  : Cb_GObject_Void; 
  1378.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1379.        After : Boolean := False); 
  1380.    --  The ::toggle-overwrite signal is a <link 
  1381.    --  linkend="keybinding-signals">keybinding signal</link> which gets emitted 
  1382.    --  to toggle the overwrite mode of the entry. 
  1383.    -- 
  1384.    --  The default bindings for this signal is Insert. 
  1385.  
  1386.    ---------------- 
  1387.    -- Interfaces -- 
  1388.    ---------------- 
  1389.    --  This class implements several interfaces. See Glib.Types 
  1390.    -- 
  1391.    --  - "Buildable" 
  1392.    -- 
  1393.    --  - "CellEditable" 
  1394.    -- 
  1395.    --  - "Editable" 
  1396.  
  1397.    package Implements_Gtk_Buildable is new Glib.Types.Implements 
  1398.      (Gtk.Buildable.Gtk_Buildable, Gtk_Entry_Record, Gtk_Entry); 
  1399.    function "+" 
  1400.      (Widget : access Gtk_Entry_Record'Class) 
  1401.    return Gtk.Buildable.Gtk_Buildable 
  1402.    renames Implements_Gtk_Buildable.To_Interface; 
  1403.    function "-" 
  1404.      (Interf : Gtk.Buildable.Gtk_Buildable) 
  1405.    return Gtk_Entry 
  1406.    renames Implements_Gtk_Buildable.To_Object; 
  1407.  
  1408.    package Implements_Gtk_Cell_Editable is new Glib.Types.Implements 
  1409.      (Gtk.Cell_Editable.Gtk_Cell_Editable, Gtk_Entry_Record, Gtk_Entry); 
  1410.    function "+" 
  1411.      (Widget : access Gtk_Entry_Record'Class) 
  1412.    return Gtk.Cell_Editable.Gtk_Cell_Editable 
  1413.    renames Implements_Gtk_Cell_Editable.To_Interface; 
  1414.    function "-" 
  1415.      (Interf : Gtk.Cell_Editable.Gtk_Cell_Editable) 
  1416.    return Gtk_Entry 
  1417.    renames Implements_Gtk_Cell_Editable.To_Object; 
  1418.  
  1419.    package Implements_Gtk_Editable is new Glib.Types.Implements 
  1420.      (Gtk.Editable.Gtk_Editable, Gtk_Entry_Record, Gtk_Entry); 
  1421.    function "+" 
  1422.      (Widget : access Gtk_Entry_Record'Class) 
  1423.    return Gtk.Editable.Gtk_Editable 
  1424.    renames Implements_Gtk_Editable.To_Interface; 
  1425.    function "-" 
  1426.      (Interf : Gtk.Editable.Gtk_Editable) 
  1427.    return Gtk_Entry 
  1428.    renames Implements_Gtk_Editable.To_Object; 
  1429.  
  1430. private 
  1431.    Xalign_Property : constant Glib.Properties.Property_Float := 
  1432.      Glib.Properties.Build ("xalign"); 
  1433.    Width_Chars_Property : constant Glib.Properties.Property_Int := 
  1434.      Glib.Properties.Build ("width-chars"); 
  1435.    Visibility_Property : constant Glib.Properties.Property_Boolean := 
  1436.      Glib.Properties.Build ("visibility"); 
  1437.    Truncate_Multiline_Property : constant Glib.Properties.Property_Boolean := 
  1438.      Glib.Properties.Build ("truncate-multiline"); 
  1439.    Text_Length_Property : constant Glib.Properties.Property_Uint := 
  1440.      Glib.Properties.Build ("text-length"); 
  1441.    Text_Property : constant Glib.Properties.Property_String := 
  1442.      Glib.Properties.Build ("text"); 
  1443.    Shadow_Type_Property : constant Gtk.Enums.Property_Gtk_Shadow_Type := 
  1444.      Gtk.Enums.Build ("shadow-type"); 
  1445.    Selection_Bound_Property : constant Glib.Properties.Property_Int := 
  1446.      Glib.Properties.Build ("selection-bound"); 
  1447.    Secondary_Icon_Tooltip_Text_Property : constant Glib.Properties.Property_String := 
  1448.      Glib.Properties.Build ("secondary-icon-tooltip-text"); 
  1449.    Secondary_Icon_Tooltip_Markup_Property : constant Glib.Properties.Property_String := 
  1450.      Glib.Properties.Build ("secondary-icon-tooltip-markup"); 
  1451.    Secondary_Icon_Storage_Type_Property : constant Gtk.Image.Property_Gtk_Image_Type := 
  1452.      Gtk.Image.Build ("secondary-icon-storage-type"); 
  1453.    Secondary_Icon_Stock_Property : constant Glib.Properties.Property_String := 
  1454.      Glib.Properties.Build ("secondary-icon-stock"); 
  1455.    Secondary_Icon_Sensitive_Property : constant Glib.Properties.Property_Boolean := 
  1456.      Glib.Properties.Build ("secondary-icon-sensitive"); 
  1457.    Secondary_Icon_Pixbuf_Property : constant Glib.Properties.Property_Object := 
  1458.      Glib.Properties.Build ("secondary-icon-pixbuf"); 
  1459.    Secondary_Icon_Name_Property : constant Glib.Properties.Property_String := 
  1460.      Glib.Properties.Build ("secondary-icon-name"); 
  1461.    Secondary_Icon_Gicon_Property : constant Glib.Properties.Property_Boxed := 
  1462.      Glib.Properties.Build ("secondary-icon-gicon"); 
  1463.    Secondary_Icon_Activatable_Property : constant Glib.Properties.Property_Boolean := 
  1464.      Glib.Properties.Build ("secondary-icon-activatable"); 
  1465.    Scroll_Offset_Property : constant Glib.Properties.Property_Int := 
  1466.      Glib.Properties.Build ("scroll-offset"); 
  1467.    Progress_Pulse_Step_Property : constant Glib.Properties.Property_Double := 
  1468.      Glib.Properties.Build ("progress-pulse-step"); 
  1469.    Progress_Fraction_Property : constant Glib.Properties.Property_Double := 
  1470.      Glib.Properties.Build ("progress-fraction"); 
  1471.    Primary_Icon_Tooltip_Text_Property : constant Glib.Properties.Property_String := 
  1472.      Glib.Properties.Build ("primary-icon-tooltip-text"); 
  1473.    Primary_Icon_Tooltip_Markup_Property : constant Glib.Properties.Property_String := 
  1474.      Glib.Properties.Build ("primary-icon-tooltip-markup"); 
  1475.    Primary_Icon_Storage_Type_Property : constant Gtk.Image.Property_Gtk_Image_Type := 
  1476.      Gtk.Image.Build ("primary-icon-storage-type"); 
  1477.    Primary_Icon_Stock_Property : constant Glib.Properties.Property_String := 
  1478.      Glib.Properties.Build ("primary-icon-stock"); 
  1479.    Primary_Icon_Sensitive_Property : constant Glib.Properties.Property_Boolean := 
  1480.      Glib.Properties.Build ("primary-icon-sensitive"); 
  1481.    Primary_Icon_Pixbuf_Property : constant Glib.Properties.Property_Object := 
  1482.      Glib.Properties.Build ("primary-icon-pixbuf"); 
  1483.    Primary_Icon_Name_Property : constant Glib.Properties.Property_String := 
  1484.      Glib.Properties.Build ("primary-icon-name"); 
  1485.    Primary_Icon_Gicon_Property : constant Glib.Properties.Property_Boxed := 
  1486.      Glib.Properties.Build ("primary-icon-gicon"); 
  1487.    Primary_Icon_Activatable_Property : constant Glib.Properties.Property_Boolean := 
  1488.      Glib.Properties.Build ("primary-icon-activatable"); 
  1489.    Populate_All_Property : constant Glib.Properties.Property_Boolean := 
  1490.      Glib.Properties.Build ("populate-all"); 
  1491.    Placeholder_Text_Property : constant Glib.Properties.Property_String := 
  1492.      Glib.Properties.Build ("placeholder-text"); 
  1493.    Overwrite_Mode_Property : constant Glib.Properties.Property_Boolean := 
  1494.      Glib.Properties.Build ("overwrite-mode"); 
  1495.    Max_Length_Property : constant Glib.Properties.Property_Int := 
  1496.      Glib.Properties.Build ("max-length"); 
  1497.    Invisible_Char_Set_Property : constant Glib.Properties.Property_Boolean := 
  1498.      Glib.Properties.Build ("invisible-char-set"); 
  1499.    Invisible_Char_Property : constant Glib.Properties.Property_Uint := 
  1500.      Glib.Properties.Build ("invisible-char"); 
  1501.    Input_Purpose_Property : constant Gtk.Enums.Property_Gtk_Input_Purpose := 
  1502.      Gtk.Enums.Build ("input-purpose"); 
  1503.    Input_Hints_Property : constant Gtk.Enums.Property_Gtk_Input_Hints := 
  1504.      Gtk.Enums.Build ("input-hints"); 
  1505.    Inner_Border_Property : constant Glib.Properties.Property_Boxed := 
  1506.      Glib.Properties.Build ("inner-border"); 
  1507.    Im_Module_Property : constant Glib.Properties.Property_String := 
  1508.      Glib.Properties.Build ("im-module"); 
  1509.    Has_Frame_Property : constant Glib.Properties.Property_Boolean := 
  1510.      Glib.Properties.Build ("has-frame"); 
  1511.    Editable_Property : constant Glib.Properties.Property_Boolean := 
  1512.      Glib.Properties.Build ("editable"); 
  1513.    Cursor_Position_Property : constant Glib.Properties.Property_Int := 
  1514.      Glib.Properties.Build ("cursor-position"); 
  1515.    Completion_Property : constant Glib.Properties.Property_Object := 
  1516.      Glib.Properties.Build ("completion"); 
  1517.    Caps_Lock_Warning_Property : constant Glib.Properties.Property_Boolean := 
  1518.      Glib.Properties.Build ("caps-lock-warning"); 
  1519.    Buffer_Property : constant Glib.Properties.Property_Object := 
  1520.      Glib.Properties.Build ("buffer"); 
  1521.    Attributes_Property : constant Glib.Properties.Property_Object := 
  1522.      Glib.Properties.Build ("attributes"); 
  1523.    Activates_Default_Property : constant Glib.Properties.Property_Boolean := 
  1524.      Glib.Properties.Build ("activates-default"); 
  1525. end Gtk.GEntry;