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 GtkComboBox is a widget that allows the user to choose from a list of 
  26. --  valid choices. The GtkComboBox displays the selected choice. When 
  27. --  activated, the GtkComboBox displays a popup which allows the user to make a 
  28. --  new choice. The style in which the selected value is displayed, and the 
  29. --  style of the popup is determined by the current theme. It may be similar to 
  30. --  a Windows-style combo box. 
  31. -- 
  32. --  The GtkComboBox uses the model-view pattern; the list of valid choices is 
  33. --  specified in the form of a tree model, and the display of the choices can 
  34. --  be adapted to the data in the model by using cell renderers, as you would 
  35. --  in a tree view. This is possible since GtkComboBox implements the 
  36. --  Gtk.Cell_Layout.Gtk_Cell_Layout interface. The tree model holding the valid 
  37. --  choices is not restricted to a flat list, it can be a real tree, and the 
  38. --  popup will reflect the tree structure. 
  39. -- 
  40. --  To allow the user to enter values not in the model, the 'has-entry' 
  41. --  property allows the GtkComboBox to contain a Gtk.GEntry.Gtk_Entry. This 
  42. --  entry can be accessed by calling Gtk.Bin.Get_Child on the combo box. 
  43. -- 
  44. --  For a simple list of textual choices, the model-view API of GtkComboBox 
  45. --  can be a bit overwhelming. In this case, 
  46. --  Gtk.Combo_Box_Text.Gtk_Combo_Box_Text offers a simple alternative. Both 
  47. --  GtkComboBox and Gtk.Combo_Box_Text.Gtk_Combo_Box_Text can contain an entry. 
  48. -- 
  49. --  </description> 
  50. --  <group>Numeric/Text Data Entry</group> 
  51. pragma Ada_2005; 
  52.  
  53. pragma Warnings (Off, "*is already use-visible*"); 
  54. with Gdk.Event;         use Gdk.Event; 
  55. with Glib;              use Glib; 
  56. with Glib.Object;       use Glib.Object; 
  57. with Glib.Properties;   use Glib.Properties; 
  58. with Glib.Types;        use Glib.Types; 
  59. with Gtk.Bin;           use Gtk.Bin; 
  60. with Gtk.Buildable;     use Gtk.Buildable; 
  61. with Gtk.Cell_Area;     use Gtk.Cell_Area; 
  62. with Gtk.Cell_Editable; use Gtk.Cell_Editable; 
  63. with Gtk.Cell_Layout;   use Gtk.Cell_Layout; 
  64. with Gtk.Cell_Renderer; use Gtk.Cell_Renderer; 
  65. with Gtk.Enums;         use Gtk.Enums; 
  66. with Gtk.Tree_Model;    use Gtk.Tree_Model; 
  67. with Gtk.Tree_View;     use Gtk.Tree_View; 
  68.  
  69. package Gtk.Combo_Box is 
  70.  
  71.    type Gtk_Combo_Box_Record is new Gtk_Bin_Record with null record; 
  72.    type Gtk_Combo_Box is access all Gtk_Combo_Box_Record'Class; 
  73.  
  74.    --------------- 
  75.    -- Callbacks -- 
  76.    --------------- 
  77.  
  78.    type Gtk_Tree_View_Row_Separator_Func is access function 
  79.      (Model : Gtk.Tree_Model.Gtk_Tree_Model; 
  80.       Iter  : Gtk.Tree_Model.Gtk_Tree_Iter) return Boolean; 
  81.    --  Function type for determining whether the row pointed to by Iter should 
  82.    --  be rendered as a separator. A common way to implement this is to have a 
  83.    --  boolean column in the model, whose values the 
  84.    --  Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func returns. 
  85.    --  "model": the Gtk.Tree_Model.Gtk_Tree_Model 
  86.    --  "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing at a row in Model 
  87.  
  88.    type Gtk_Cell_Layout_Data_Func is access procedure 
  89.      (Cell_Layout : Gtk.Cell_Layout.Gtk_Cell_Layout; 
  90.       Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  91.       Tree_Model  : Gtk.Tree_Model.Gtk_Tree_Model; 
  92.       Iter        : Gtk.Tree_Model.Gtk_Tree_Iter); 
  93.    --  A function which should set the value of Cell_Layout's cell renderer(s) 
  94.    --  as appropriate. 
  95.    --  "cell_layout": a Gtk.Cell_Layout.Gtk_Cell_Layout 
  96.    --  "cell": the cell renderer whose value is to be set 
  97.    --  "tree_model": the model 
  98.    --  "iter": a Gtk.Tree_Model.Gtk_Tree_Iter indicating the row to set the 
  99.    --  value for 
  100.  
  101.    ------------------ 
  102.    -- Constructors -- 
  103.    ------------------ 
  104.  
  105.    procedure Gtk_New (Combo_Box : out Gtk_Combo_Box); 
  106.    procedure Initialize 
  107.       (Combo_Box : not null access Gtk_Combo_Box_Record'Class); 
  108.    --  Creates a new empty Gtk.Combo_Box.Gtk_Combo_Box. 
  109.    --  Since: gtk+ 2.4 
  110.  
  111.    function Gtk_Combo_Box_New return Gtk_Combo_Box; 
  112.    --  Creates a new empty Gtk.Combo_Box.Gtk_Combo_Box. 
  113.    --  Since: gtk+ 2.4 
  114.  
  115.    procedure Gtk_New_With_Area 
  116.       (Combo_Box : out Gtk_Combo_Box; 
  117.        Area      : not null access Gtk.Cell_Area.Gtk_Cell_Area_Record'Class); 
  118.    procedure Initialize_With_Area 
  119.       (Combo_Box : not null access Gtk_Combo_Box_Record'Class; 
  120.        Area      : not null access Gtk.Cell_Area.Gtk_Cell_Area_Record'Class); 
  121.    --  Creates a new empty Gtk.Combo_Box.Gtk_Combo_Box using Area to layout 
  122.    --  cells. 
  123.    --  "area": the Gtk.Cell_Area.Gtk_Cell_Area to use to layout cell renderers 
  124.  
  125.    function Gtk_Combo_Box_New_With_Area 
  126.       (Area : not null access Gtk.Cell_Area.Gtk_Cell_Area_Record'Class) 
  127.        return Gtk_Combo_Box; 
  128.    --  Creates a new empty Gtk.Combo_Box.Gtk_Combo_Box using Area to layout 
  129.    --  cells. 
  130.    --  "area": the Gtk.Cell_Area.Gtk_Cell_Area to use to layout cell renderers 
  131.  
  132.    procedure Gtk_New_With_Area_And_Entry 
  133.       (Combo_Box : out Gtk_Combo_Box; 
  134.        Area      : not null access Gtk.Cell_Area.Gtk_Cell_Area_Record'Class); 
  135.    procedure Initialize_With_Area_And_Entry 
  136.       (Combo_Box : not null access Gtk_Combo_Box_Record'Class; 
  137.        Area      : not null access Gtk.Cell_Area.Gtk_Cell_Area_Record'Class); 
  138.    --  Creates a new empty Gtk.Combo_Box.Gtk_Combo_Box with an entry. 
  139.    --  The new combo box will use Area to layout cells. 
  140.    --  "area": the Gtk.Cell_Area.Gtk_Cell_Area to use to layout cell renderers 
  141.  
  142.    function Gtk_Combo_Box_New_With_Area_And_Entry 
  143.       (Area : not null access Gtk.Cell_Area.Gtk_Cell_Area_Record'Class) 
  144.        return Gtk_Combo_Box; 
  145.    --  Creates a new empty Gtk.Combo_Box.Gtk_Combo_Box with an entry. 
  146.    --  The new combo box will use Area to layout cells. 
  147.    --  "area": the Gtk.Cell_Area.Gtk_Cell_Area to use to layout cell renderers 
  148.  
  149.    procedure Gtk_New_With_Entry (Combo_Box : out Gtk_Combo_Box); 
  150.    procedure Initialize_With_Entry 
  151.       (Combo_Box : not null access Gtk_Combo_Box_Record'Class); 
  152.    --  Creates a new empty Gtk.Combo_Box.Gtk_Combo_Box with an entry. 
  153.  
  154.    function Gtk_Combo_Box_New_With_Entry return Gtk_Combo_Box; 
  155.    --  Creates a new empty Gtk.Combo_Box.Gtk_Combo_Box with an entry. 
  156.  
  157.    procedure Gtk_New_With_Model 
  158.       (Combo_Box : out Gtk_Combo_Box; 
  159.        Model     : Gtk.Tree_Model.Gtk_Tree_Model); 
  160.    procedure Initialize_With_Model 
  161.       (Combo_Box : not null access Gtk_Combo_Box_Record'Class; 
  162.        Model     : Gtk.Tree_Model.Gtk_Tree_Model); 
  163.    --  Creates a new Gtk.Combo_Box.Gtk_Combo_Box with the model initialized to 
  164.    --  Model. 
  165.    --  Since: gtk+ 2.4 
  166.    --  "model": A Gtk.Tree_Model.Gtk_Tree_Model. 
  167.  
  168.    function Gtk_Combo_Box_New_With_Model 
  169.       (Model : Gtk.Tree_Model.Gtk_Tree_Model) return Gtk_Combo_Box; 
  170.    --  Creates a new Gtk.Combo_Box.Gtk_Combo_Box with the model initialized to 
  171.    --  Model. 
  172.    --  Since: gtk+ 2.4 
  173.    --  "model": A Gtk.Tree_Model.Gtk_Tree_Model. 
  174.  
  175.    procedure Gtk_New_With_Model_And_Entry 
  176.       (Combo_Box : out Gtk_Combo_Box; 
  177.        Model     : Gtk.Tree_Model.Gtk_Tree_Model); 
  178.    procedure Initialize_With_Model_And_Entry 
  179.       (Combo_Box : not null access Gtk_Combo_Box_Record'Class; 
  180.        Model     : Gtk.Tree_Model.Gtk_Tree_Model); 
  181.    --  Creates a new empty Gtk.Combo_Box.Gtk_Combo_Box with an entry and with 
  182.    --  the model initialized to Model. 
  183.    --  "model": A Gtk.Tree_Model.Gtk_Tree_Model 
  184.  
  185.    function Gtk_Combo_Box_New_With_Model_And_Entry 
  186.       (Model : Gtk.Tree_Model.Gtk_Tree_Model) return Gtk_Combo_Box; 
  187.    --  Creates a new empty Gtk.Combo_Box.Gtk_Combo_Box with an entry and with 
  188.    --  the model initialized to Model. 
  189.    --  "model": A Gtk.Tree_Model.Gtk_Tree_Model 
  190.  
  191.    function Get_Type return Glib.GType; 
  192.    pragma Import (C, Get_Type, "gtk_combo_box_get_type"); 
  193.  
  194.    ------------- 
  195.    -- Methods -- 
  196.    ------------- 
  197.  
  198.    function Get_Active 
  199.       (Combo_Box : not null access Gtk_Combo_Box_Record) return Gint; 
  200.    --  Returns the index of the currently active item, or -1 if there's no 
  201.    --  active item. If the model is a non-flat treemodel, and the active item 
  202.    --  is not an immediate child of the root of the tree, this function returns 
  203.    --  'gtk_tree_path_get_indices (path)[0]', where 'path' is the 
  204.    --  Gtk.Tree_Model.Gtk_Tree_Path of the active item. 
  205.    --  Since: gtk+ 2.4 
  206.  
  207.    procedure Set_Active 
  208.       (Combo_Box : not null access Gtk_Combo_Box_Record; 
  209.        Index     : Gint); 
  210.    --  Sets the active item of Combo_Box to be the item at Index. 
  211.    --  Since: gtk+ 2.4 
  212.    --  "index_": An index in the model passed during construction, or -1 to 
  213.    --  have no active item 
  214.  
  215.    function Get_Active_Id 
  216.       (Combo_Box : not null access Gtk_Combo_Box_Record) return UTF8_String; 
  217.    --  Returns the ID of the active row of Combo_Box. This value is taken from 
  218.    --  the active row and the column specified by the 
  219.    --  Gtk.Combo_Box.Gtk_Combo_Box:id-column property of Combo_Box (see 
  220.    --  Gtk.Combo_Box.Set_Id_Column). 
  221.    --  The returned value is an interned string which means that you can 
  222.    --  compare the pointer by value to other interned strings and that you must 
  223.    --  not free it. 
  224.    --  If the Gtk.Combo_Box.Gtk_Combo_Box:id-column property of Combo_Box is 
  225.    --  not set, or if no row is active, or if the active row has a null ID 
  226.    --  value, then null is returned. 
  227.    --  Since: gtk+ 3.0 
  228.  
  229.    function Set_Active_Id 
  230.       (Combo_Box : not null access Gtk_Combo_Box_Record; 
  231.        Active_Id : UTF8_String := "") return Boolean; 
  232.    --  Changes the active row of Combo_Box to the one that has an ID equal to 
  233.    --  Active_Id, or unsets the active row if Active_Id is null. Rows having a 
  234.    --  null ID string cannot be made active by this function. 
  235.    --  If the Gtk.Combo_Box.Gtk_Combo_Box:id-column property of Combo_Box is 
  236.    --  unset or if no row has the given ID then the function does nothing and 
  237.    --  returns False. 
  238.    --  Since: gtk+ 3.0 
  239.    --  "active_id": the ID of the row to select, or null 
  240.  
  241.    function Get_Add_Tearoffs 
  242.       (Combo_Box : not null access Gtk_Combo_Box_Record) return Boolean; 
  243.    --  Gets the current value of the :add-tearoffs property. 
  244.  
  245.    procedure Set_Add_Tearoffs 
  246.       (Combo_Box    : not null access Gtk_Combo_Box_Record; 
  247.        Add_Tearoffs : Boolean); 
  248.    --  Sets whether the popup menu should have a tearoff menu item. 
  249.    --  Since: gtk+ 2.6 
  250.    --  "add_tearoffs": True to add tearoff menu items 
  251.  
  252.    function Get_Button_Sensitivity 
  253.       (Combo_Box : not null access Gtk_Combo_Box_Record) 
  254.        return Gtk.Enums.Gtk_Sensitivity_Type; 
  255.    --  Returns whether the combo box sets the dropdown button sensitive or not 
  256.    --  when there are no items in the model. 
  257.    --  Since: gtk+ 2.14 
  258.  
  259.    procedure Set_Button_Sensitivity 
  260.       (Combo_Box   : not null access Gtk_Combo_Box_Record; 
  261.        Sensitivity : Gtk.Enums.Gtk_Sensitivity_Type); 
  262.    --  Sets whether the dropdown button of the combo box should be always 
  263.    --  sensitive (Gtk.Enums.Sensitivity_On), never sensitive 
  264.    --  (Gtk.Enums.Sensitivity_Off) or only if there is at least one item to 
  265.    --  display (Gtk.Enums.Sensitivity_Auto). 
  266.    --  Since: gtk+ 2.14 
  267.    --  "sensitivity": specify the sensitivity of the dropdown button 
  268.  
  269.    function Get_Column_Span_Column 
  270.       (Combo_Box : not null access Gtk_Combo_Box_Record) return Gint; 
  271.    --  Returns the column with column span information for Combo_Box. 
  272.    --  Since: gtk+ 2.6 
  273.  
  274.    procedure Set_Column_Span_Column 
  275.       (Combo_Box   : not null access Gtk_Combo_Box_Record; 
  276.        Column_Span : Gint); 
  277.    --  Sets the column with column span information for Combo_Box to be 
  278.    --  Column_Span. The column span column contains integers which indicate how 
  279.    --  many columns an item should span. 
  280.    --  Since: gtk+ 2.4 
  281.    --  "column_span": A column in the model passed during construction 
  282.  
  283.    function Get_Entry_Text_Column 
  284.       (Combo_Box : not null access Gtk_Combo_Box_Record) return Gint; 
  285.    --  Returns the column which Combo_Box is using to get the strings from to 
  286.    --  display in the internal entry. 
  287.    --  Since: gtk+ 2.24 
  288.  
  289.    procedure Set_Entry_Text_Column 
  290.       (Combo_Box   : not null access Gtk_Combo_Box_Record; 
  291.        Text_Column : Gint); 
  292.    --  Sets the model column which Combo_Box should use to get strings from to 
  293.    --  be Text_Column. The column Text_Column in the model of Combo_Box must be 
  294.    --  of type G_TYPE_STRING. 
  295.    --  This is only relevant if Combo_Box has been created with 
  296.    --  Gtk.Combo_Box.Gtk_Combo_Box:has-entry as True. 
  297.    --  Since: gtk+ 2.24 
  298.    --  "text_column": A column in Model to get the strings from for the 
  299.    --  internal entry 
  300.  
  301.    function Get_Focus_On_Click 
  302.       (Combo_Box : not null access Gtk_Combo_Box_Record) return Boolean; 
  303.    --  Returns whether the combo box grabs focus when it is clicked with the 
  304.    --  mouse. See Gtk.Combo_Box.Set_Focus_On_Click. 
  305.    --  Since: gtk+ 2.6 
  306.  
  307.    procedure Set_Focus_On_Click 
  308.       (Combo_Box      : not null access Gtk_Combo_Box_Record; 
  309.        Focus_On_Click : Boolean); 
  310.    --  Sets whether the combo box will grab focus when it is clicked with the 
  311.    --  mouse. Making mouse clicks not grab focus is useful in places like 
  312.    --  toolbars where you don't want the keyboard focus removed from the main 
  313.    --  area of the application. 
  314.    --  Since: gtk+ 2.6 
  315.    --  "focus_on_click": whether the combo box grabs focus when clicked with 
  316.    --  the mouse 
  317.  
  318.    function Get_Has_Entry 
  319.       (Combo_Box : not null access Gtk_Combo_Box_Record) return Boolean; 
  320.    --  Returns whether the combo box has an entry. 
  321.    --  Since: gtk+ 2.24 
  322.  
  323.    function Get_Id_Column 
  324.       (Combo_Box : not null access Gtk_Combo_Box_Record) return Gint; 
  325.    --  Returns the column which Combo_Box is using to get string IDs for 
  326.    --  values from. 
  327.    --  Since: gtk+ 3.0 
  328.  
  329.    procedure Set_Id_Column 
  330.       (Combo_Box : not null access Gtk_Combo_Box_Record; 
  331.        Id_Column : Gint); 
  332.    --  Sets the model column which Combo_Box should use to get string IDs for 
  333.    --  values from. The column Id_Column in the model of Combo_Box must be of 
  334.    --  type G_TYPE_STRING. 
  335.    --  Since: gtk+ 3.0 
  336.    --  "id_column": A column in Model to get string IDs for values from 
  337.  
  338.    function Get_Model 
  339.       (Combo_Box : not null access Gtk_Combo_Box_Record) 
  340.        return Gtk.Tree_Model.Gtk_Tree_Model; 
  341.    --  Returns the Gtk.Tree_Model.Gtk_Tree_Model which is acting as data 
  342.    --  source for Combo_Box. 
  343.    --  Since: gtk+ 2.4 
  344.  
  345.    procedure Set_Model 
  346.       (Combo_Box : not null access Gtk_Combo_Box_Record; 
  347.        Model     : Gtk.Tree_Model.Gtk_Tree_Model); 
  348.    --  Sets the model used by Combo_Box to be Model. Will unset a previously 
  349.    --  set model (if applicable). If model is null, then it will unset the 
  350.    --  model. 
  351.    --  Note that this function does not clear the cell renderers, you have to 
  352.    --  call Gtk.Cell_Layout.Clear yourself if you need to set up different cell 
  353.    --  renderers for the new model. 
  354.    --  Since: gtk+ 2.4 
  355.    --  "model": A Gtk.Tree_Model.Gtk_Tree_Model 
  356.  
  357.    function Get_Popup_Fixed_Width 
  358.       (Combo_Box : not null access Gtk_Combo_Box_Record) return Boolean; 
  359.    --  Gets whether the popup uses a fixed width matching the allocated width 
  360.    --  of the combo box. 
  361.    --  Since: gtk+ 3.0 
  362.  
  363.    procedure Set_Popup_Fixed_Width 
  364.       (Combo_Box : not null access Gtk_Combo_Box_Record; 
  365.        Fixed     : Boolean); 
  366.    --  Specifies whether the popup's width should be a fixed width matching 
  367.    --  the allocated width of the combo box. 
  368.    --  Since: gtk+ 3.0 
  369.    --  "fixed": whether to use a fixed popup width 
  370.  
  371.    procedure Get_Row_Separator_Func 
  372.       (Combo_Box : not null access Gtk_Combo_Box_Record); 
  373.    --  Returns the current row separator function. 
  374.    --  Since: gtk+ 2.6 
  375.  
  376.    procedure Set_Row_Separator_Func 
  377.       (Combo_Box : not null access Gtk_Combo_Box_Record; 
  378.        Func      : Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func); 
  379.    --  Sets the row separator function, which is used to determine whether a 
  380.    --  row should be drawn as a separator. If the row separator function is 
  381.    --  null, no separators are drawn. This is the default value. 
  382.    --  Since: gtk+ 2.6 
  383.    --  "func": a Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func 
  384.  
  385.    function Get_Row_Span_Column 
  386.       (Combo_Box : not null access Gtk_Combo_Box_Record) return Gint; 
  387.    --  Returns the column with row span information for Combo_Box. 
  388.    --  Since: gtk+ 2.6 
  389.  
  390.    procedure Set_Row_Span_Column 
  391.       (Combo_Box : not null access Gtk_Combo_Box_Record; 
  392.        Row_Span  : Gint); 
  393.    --  Sets the column with row span information for Combo_Box to be Row_Span. 
  394.    --  The row span column contains integers which indicate how many rows an 
  395.    --  item should span. 
  396.    --  Since: gtk+ 2.4 
  397.    --  "row_span": A column in the model passed during construction. 
  398.  
  399.    function Get_Title 
  400.       (Combo_Box : not null access Gtk_Combo_Box_Record) return UTF8_String; 
  401.    --  Gets the current title of the menu in tearoff mode. See 
  402.    --  Gtk.Combo_Box.Set_Add_Tearoffs. 
  403.    --  Since: gtk+ 2.10 
  404.  
  405.    procedure Set_Title 
  406.       (Combo_Box : not null access Gtk_Combo_Box_Record; 
  407.        Title     : UTF8_String); 
  408.    --  Sets the menu's title in tearoff mode. 
  409.    --  Since: gtk+ 2.10 
  410.    --  "title": a title for the menu in tearoff mode 
  411.  
  412.    function Get_Wrap_Width 
  413.       (Combo_Box : not null access Gtk_Combo_Box_Record) return Gint; 
  414.    --  Returns the wrap width which is used to determine the number of columns 
  415.    --  for the popup menu. If the wrap width is larger than 1, the combo box is 
  416.    --  in table mode. 
  417.    --  Since: gtk+ 2.6 
  418.  
  419.    procedure Set_Wrap_Width 
  420.       (Combo_Box : not null access Gtk_Combo_Box_Record; 
  421.        Width     : Gint); 
  422.    --  Sets the wrap width of Combo_Box to be Width. The wrap width is 
  423.    --  basically the preferred number of columns when you want the popup to be 
  424.    --  layed out in a table. 
  425.    --  Since: gtk+ 2.4 
  426.    --  "width": Preferred number of columns 
  427.  
  428.    procedure Popdown (Combo_Box : not null access Gtk_Combo_Box_Record); 
  429.    --  Hides the menu or dropdown list of Combo_Box. 
  430.    --  This function is mostly intended for use by accessibility technologies; 
  431.    --  applications should have little use for it. 
  432.    --  Since: gtk+ 2.4 
  433.  
  434.    procedure Popup (Combo_Box : not null access Gtk_Combo_Box_Record); 
  435.    --  Pops up the menu or dropdown list of Combo_Box. 
  436.    --  This function is mostly intended for use by accessibility technologies; 
  437.    --  applications should have little use for it. 
  438.    --  Since: gtk+ 2.4 
  439.  
  440.    procedure Set_Active_Iter 
  441.       (Combo_Box : not null access Gtk_Combo_Box_Record; 
  442.        Iter      : Gtk.Tree_Model.Gtk_Tree_Iter); 
  443.    --  Sets the current active item to be the one referenced by Iter, or 
  444.    --  unsets the active item if Iter is null. 
  445.    --  Since: gtk+ 2.4 
  446.    --  "iter": The Gtk.Tree_Model.Gtk_Tree_Iter, or null 
  447.  
  448.    generic 
  449.       type User_Data_Type (<>) is private; 
  450.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  451.    package Set_Row_Separator_Func_User_Data is 
  452.  
  453.       type Gtk_Tree_View_Row_Separator_Func is access function 
  454.         (Model : Gtk.Tree_Model.Gtk_Tree_Model; 
  455.          Iter  : Gtk.Tree_Model.Gtk_Tree_Iter; 
  456.          Data  : User_Data_Type) return Boolean; 
  457.       --  Function type for determining whether the row pointed to by Iter should 
  458.       --  be rendered as a separator. A common way to implement this is to have a 
  459.       --  boolean column in the model, whose values the 
  460.       --  Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func returns. 
  461.       --  "model": the Gtk.Tree_Model.Gtk_Tree_Model 
  462.       --  "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing at a row in Model 
  463.       --  "data": user data 
  464.  
  465.       procedure Set_Row_Separator_Func 
  466.          (Combo_Box : not null access Gtk.Combo_Box.Gtk_Combo_Box_Record'Class; 
  467.           Func      : Gtk_Tree_View_Row_Separator_Func; 
  468.           Data      : User_Data_Type); 
  469.       --  Sets the row separator function, which is used to determine whether 
  470.       --  a row should be drawn as a separator. If the row separator function 
  471.       --  is null, no separators are drawn. This is the default value. 
  472.       --  Since: gtk+ 2.6 
  473.       --  "func": a Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func 
  474.       --  "data": user data to pass to Func, or null 
  475.  
  476.    end Set_Row_Separator_Func_User_Data; 
  477.  
  478.    procedure Set_Cell_Data_Func 
  479.       (Cell_Layout : not null access Gtk_Combo_Box_Record; 
  480.        Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  481.        Func        : Gtk_Cell_Layout_Data_Func); 
  482.    --  Sets the Gtk_Cell_Layout_Data_Func to use for Cell_Layout. 
  483.    --  This function is used instead of the standard attributes mapping for 
  484.    --  setting the column value, and should set the value of Cell_Layout's cell 
  485.    --  renderer(s) as appropriate. 
  486.    --  Func may be null to remove a previously set function. 
  487.    --  Since: gtk+ 2.4 
  488.    --  "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer 
  489.    --  "func": the Gtk_Cell_Layout_Data_Func to use, or null 
  490.  
  491.    generic 
  492.       type User_Data_Type (<>) is private; 
  493.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  494.    package Set_Cell_Data_Func_User_Data is 
  495.  
  496.       type Gtk_Cell_Layout_Data_Func is access procedure 
  497.         (Cell_Layout : Gtk.Cell_Layout.Gtk_Cell_Layout; 
  498.          Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  499.          Tree_Model  : Gtk.Tree_Model.Gtk_Tree_Model; 
  500.          Iter        : Gtk.Tree_Model.Gtk_Tree_Iter; 
  501.          Data        : User_Data_Type); 
  502.       --  A function which should set the value of Cell_Layout's cell renderer(s) 
  503.       --  as appropriate. 
  504.       --  "cell_layout": a Gtk.Cell_Layout.Gtk_Cell_Layout 
  505.       --  "cell": the cell renderer whose value is to be set 
  506.       --  "tree_model": the model 
  507.       --  "iter": a Gtk.Tree_Model.Gtk_Tree_Iter indicating the row to set the 
  508.       --  value for 
  509.       --  "data": user data passed to Gtk.Cell_Layout.Set_Cell_Data_Func 
  510.  
  511.       procedure Set_Cell_Data_Func 
  512.          (Cell_Layout : not null access Gtk.Combo_Box.Gtk_Combo_Box_Record'Class; 
  513.           Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  514.           Func        : Gtk_Cell_Layout_Data_Func; 
  515.           Func_Data   : User_Data_Type); 
  516.       --  Sets the Gtk_Cell_Layout_Data_Func to use for Cell_Layout. 
  517.       --  This function is used instead of the standard attributes mapping for 
  518.       --  setting the column value, and should set the value of Cell_Layout's 
  519.       --  cell renderer(s) as appropriate. 
  520.       --  Func may be null to remove a previously set function. 
  521.       --  Since: gtk+ 2.4 
  522.       --  "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer 
  523.       --  "func": the Gtk_Cell_Layout_Data_Func to use, or null 
  524.       --  "func_data": user data for Func 
  525.  
  526.    end Set_Cell_Data_Func_User_Data; 
  527.  
  528.    ---------------------- 
  529.    -- GtkAda additions -- 
  530.    ---------------------- 
  531.  
  532.    function Get_Active_Iter 
  533.      (Combo_Box : not null access Gtk_Combo_Box_Record) 
  534.    return Gtk.Tree_Model.Gtk_Tree_Iter; 
  535.    --  Return the currently active iter 
  536.  
  537.    function Get_Active_Text 
  538.      (Combo_Box : not null access Gtk_Combo_Box_Record) 
  539.    return UTF8_String; 
  540.    --  Return the text present in the entry if it has one, or the empty string 
  541.  
  542.    --------------------------------------------- 
  543.    -- Inherited subprograms (from interfaces) -- 
  544.    --------------------------------------------- 
  545.    --  Methods inherited from the Buildable interface are not duplicated here 
  546.    --  since they are meant to be used by tools, mostly. If you need to call 
  547.    --  them, use an explicit cast through the "-" operator below. 
  548.  
  549.    procedure Editing_Done 
  550.       (Cell_Editable : not null access Gtk_Combo_Box_Record); 
  551.  
  552.    procedure Remove_Widget 
  553.       (Cell_Editable : not null access Gtk_Combo_Box_Record); 
  554.  
  555.    procedure Start_Editing 
  556.       (Cell_Editable : not null access Gtk_Combo_Box_Record; 
  557.        Event         : Gdk.Event.Gdk_Event); 
  558.  
  559.    procedure Add_Attribute 
  560.       (Cell_Layout : not null access Gtk_Combo_Box_Record; 
  561.        Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  562.        Attribute   : UTF8_String; 
  563.        Column      : Gint); 
  564.  
  565.    procedure Clear (Cell_Layout : not null access Gtk_Combo_Box_Record); 
  566.  
  567.    procedure Clear_Attributes 
  568.       (Cell_Layout : not null access Gtk_Combo_Box_Record; 
  569.        Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class); 
  570.  
  571.    function Get_Cells 
  572.       (Cell_Layout : not null access Gtk_Combo_Box_Record) 
  573.        return Glib.Object.Object_Simple_List.Glist; 
  574.  
  575.    procedure Pack_End 
  576.       (Cell_Layout : not null access Gtk_Combo_Box_Record; 
  577.        Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  578.        Expand      : Boolean); 
  579.  
  580.    procedure Pack_Start 
  581.       (Cell_Layout : not null access Gtk_Combo_Box_Record; 
  582.        Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  583.        Expand      : Boolean); 
  584.  
  585.    procedure Reorder 
  586.       (Cell_Layout : not null access Gtk_Combo_Box_Record; 
  587.        Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  588.        Position    : Gint); 
  589.  
  590.    ---------------- 
  591.    -- Properties -- 
  592.    ---------------- 
  593.    --  The following properties are defined for this widget. See 
  594.    --  Glib.Properties for more information on properties) 
  595.  
  596.    Active_Property : constant Glib.Properties.Property_Int; 
  597.    --  The item which is currently active. If the model is a non-flat 
  598.    --  treemodel, and the active item is not an immediate child of the root of 
  599.    --  the tree, this property has the value 'gtk_tree_path_get_indices 
  600.    --  (path)[0]', where 'path' is the Gtk.Tree_Model.Gtk_Tree_Path of the 
  601.    --  active item. 
  602.  
  603.    Active_Id_Property : constant Glib.Properties.Property_String; 
  604.    --  The value of the ID column of the active row. 
  605.  
  606.    Add_Tearoffs_Property : constant Glib.Properties.Property_Boolean; 
  607.    --  The add-tearoffs property controls whether generated menus have tearoff 
  608.    --  menu items. 
  609.    -- 
  610.    --  Note that this only affects menu style combo boxes. 
  611.  
  612.    Button_Sensitivity_Property : constant Gtk.Enums.Property_Gtk_Sensitivity_Type; 
  613.    --  Whether the dropdown button is sensitive when the model is empty. 
  614.  
  615.    Cell_Area_Property : constant Glib.Properties.Property_Object; 
  616.    --  Type: Gtk.Cell_Area.Gtk_Cell_Area 
  617.    --  The Gtk.Cell_Area.Gtk_Cell_Area used to layout cell renderers for this 
  618.    --  combo box. 
  619.    -- 
  620.    --  If no area is specified when creating the combo box with 
  621.    --  Gtk.Combo_Box.Gtk_New_With_Area a horizontally oriented 
  622.    --  Gtk.Cell_Area_Box.Gtk_Cell_Area_Box will be used. 
  623.  
  624.    Column_Span_Column_Property : constant Glib.Properties.Property_Int; 
  625.    --  If this is set to a non-negative value, it must be the index of a 
  626.    --  column of type G_TYPE_INT in the model. 
  627.    -- 
  628.    --  The values of that column are used to determine how many columns a 
  629.    --  value in the list will span. 
  630.  
  631.    Entry_Text_Column_Property : constant Glib.Properties.Property_Int; 
  632.    --  The column in the combo box's model to associate with strings from the 
  633.    --  entry if the combo was created with 
  634.    --  Gtk.Combo_Box.Gtk_Combo_Box:has-entry = True. 
  635.  
  636.    Focus_On_Click_Property : constant Glib.Properties.Property_Boolean; 
  637.  
  638.    Has_Entry_Property : constant Glib.Properties.Property_Boolean; 
  639.    --  Whether the combo box has an entry. 
  640.  
  641.    Has_Frame_Property : constant Glib.Properties.Property_Boolean; 
  642.    --  The has-frame property controls whether a frame is drawn around the 
  643.    --  entry. 
  644.  
  645.    Id_Column_Property : constant Glib.Properties.Property_Int; 
  646.    --  The column in the combo box's model that provides string IDs for the 
  647.    --  values in the model, if != -1. 
  648.  
  649.    Model_Property : constant Glib.Properties.Property_Interface; 
  650.    --  Type: Gtk.Tree_Model.Gtk_Tree_Model 
  651.    --  The model from which the combo box takes the values shown in the list. 
  652.  
  653.    Popup_Fixed_Width_Property : constant Glib.Properties.Property_Boolean; 
  654.    --  Whether the popup's width should be a fixed width matching the 
  655.    --  allocated width of the combo box. 
  656.  
  657.    Popup_Shown_Property : constant Glib.Properties.Property_Boolean; 
  658.    --  Whether the combo boxes dropdown is popped up. Note that this property 
  659.    --  is mainly useful, because it allows you to connect to 
  660.    --  notify::popup-shown. 
  661.  
  662.    Row_Span_Column_Property : constant Glib.Properties.Property_Int; 
  663.    --  If this is set to a non-negative value, it must be the index of a 
  664.    --  column of type G_TYPE_INT in the model. 
  665.    -- 
  666.    --  The values of that column are used to determine how many rows a value 
  667.    --  in the list will span. Therefore, the values in the model column pointed 
  668.    --  to by this property must be greater than zero and not larger than 
  669.    --  wrap-width. 
  670.  
  671.    Tearoff_Title_Property : constant Glib.Properties.Property_String; 
  672.    --  A title that may be displayed by the window manager when the popup is 
  673.    --  torn-off. 
  674.  
  675.    Wrap_Width_Property : constant Glib.Properties.Property_Int; 
  676.    --  If wrap-width is set to a positive value, the list will be displayed in 
  677.    --  multiple columns, the number of columns is determined by wrap-width. 
  678.  
  679.    ------------- 
  680.    -- Signals -- 
  681.    ------------- 
  682.  
  683.    type Cb_Gtk_Combo_Box_Void is not null access procedure (Self : access Gtk_Combo_Box_Record'Class); 
  684.  
  685.    type Cb_GObject_Void is not null access procedure 
  686.      (Self : access Glib.Object.GObject_Record'Class); 
  687.  
  688.    Signal_Changed : constant Glib.Signal_Name := "changed"; 
  689.    procedure On_Changed 
  690.       (Self  : not null access Gtk_Combo_Box_Record; 
  691.        Call  : Cb_Gtk_Combo_Box_Void; 
  692.        After : Boolean := False); 
  693.    procedure On_Changed 
  694.       (Self  : not null access Gtk_Combo_Box_Record; 
  695.        Call  : Cb_GObject_Void; 
  696.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  697.        After : Boolean := False); 
  698.    --  The changed signal is emitted when the active item is changed. The can 
  699.    --  be due to the user selecting a different item from the list, or due to a 
  700.    --  call to Gtk.Combo_Box.Set_Active_Iter. It will also be emitted while 
  701.    --  typing into the entry of a combo box with an entry. 
  702.  
  703.    type Cb_Gtk_Combo_Box_UTF8_String_UTF8_String is not null access function 
  704.      (Self : access Gtk_Combo_Box_Record'Class; 
  705.       Path : UTF8_String) return UTF8_String; 
  706.  
  707.    type Cb_GObject_UTF8_String_UTF8_String is not null access function 
  708.      (Self : access Glib.Object.GObject_Record'Class; 
  709.       Path : UTF8_String) return UTF8_String; 
  710.  
  711.    Signal_Format_Entry_Text : constant Glib.Signal_Name := "format-entry-text"; 
  712.    procedure On_Format_Entry_Text 
  713.       (Self  : not null access Gtk_Combo_Box_Record; 
  714.        Call  : Cb_Gtk_Combo_Box_UTF8_String_UTF8_String; 
  715.        After : Boolean := False); 
  716.    procedure On_Format_Entry_Text 
  717.       (Self  : not null access Gtk_Combo_Box_Record; 
  718.        Call  : Cb_GObject_UTF8_String_UTF8_String; 
  719.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  720.        After : Boolean := False); 
  721.    --  For combo boxes that are created with an entry (See 
  722.    --  GtkComboBox:has-entry). 
  723.    -- 
  724.    --  A signal which allows you to change how the text displayed in a combo 
  725.    --  box's entry is displayed. 
  726.    -- 
  727.    --  Connect a signal handler which returns an allocated string representing 
  728.    --  Path. That string will then be used to set the text in the combo box's 
  729.    --  entry. The default signal handler uses the text from the 
  730.    --  GtkComboBox::entry-text-column model column. 
  731.    -- 
  732.    --  Here's an example signal handler which fetches data from the model and 
  733.    --  displays it in the entry. |[ static gchar* format_entry_text_callback 
  734.    --  (GtkComboBox *combo, const gchar *path, gpointer user_data) { 
  735.    --  GtkTreeIter iter; GtkTreeModel model; gdouble value; model = 
  736.    --  gtk_combo_box_get_model (combo); 
  737.    -- 
  738.    --  gtk_tree_model_get_iter_from_string (model, &iter, path); 
  739.    --  gtk_tree_model_get (model, &iter, THE_DOUBLE_VALUE_COLUMN, &value, -1); 
  740.    -- 
  741.    --  return g_strdup_printf ("%g", value); } ]| 
  742.    --  
  743.    --  Callback parameters: 
  744.    --    --  "path": the GtkTreePath string from the combo box's current model to 
  745.    --    --  format text for 
  746.    --    --  Returns a newly allocated string representing Path for the current GtkComboBox model. 
  747.  
  748.    type Cb_Gtk_Combo_Box_Gtk_Scroll_Type_Void is not null access procedure 
  749.      (Self        : access Gtk_Combo_Box_Record'Class; 
  750.       Scroll_Type : Gtk.Enums.Gtk_Scroll_Type); 
  751.  
  752.    type Cb_GObject_Gtk_Scroll_Type_Void is not null access procedure 
  753.      (Self        : access Glib.Object.GObject_Record'Class; 
  754.       Scroll_Type : Gtk.Enums.Gtk_Scroll_Type); 
  755.  
  756.    Signal_Move_Active : constant Glib.Signal_Name := "move-active"; 
  757.    procedure On_Move_Active 
  758.       (Self  : not null access Gtk_Combo_Box_Record; 
  759.        Call  : Cb_Gtk_Combo_Box_Gtk_Scroll_Type_Void; 
  760.        After : Boolean := False); 
  761.    procedure On_Move_Active 
  762.       (Self  : not null access Gtk_Combo_Box_Record; 
  763.        Call  : Cb_GObject_Gtk_Scroll_Type_Void; 
  764.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  765.        After : Boolean := False); 
  766.    --  The ::move-active signal is a <link 
  767.    --  linkend="keybinding-signals">keybinding signal</link> which gets emitted 
  768.    --  to move the active selection. 
  769.  
  770.    type Cb_Gtk_Combo_Box_Boolean is not null access function 
  771.      (Self : access Gtk_Combo_Box_Record'Class) return Boolean; 
  772.  
  773.    type Cb_GObject_Boolean is not null access function 
  774.      (Self : access Glib.Object.GObject_Record'Class) 
  775.    return Boolean; 
  776.  
  777.    Signal_Popdown : constant Glib.Signal_Name := "popdown"; 
  778.    procedure On_Popdown 
  779.       (Self  : not null access Gtk_Combo_Box_Record; 
  780.        Call  : Cb_Gtk_Combo_Box_Boolean; 
  781.        After : Boolean := False); 
  782.    procedure On_Popdown 
  783.       (Self  : not null access Gtk_Combo_Box_Record; 
  784.        Call  : Cb_GObject_Boolean; 
  785.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  786.        After : Boolean := False); 
  787.    --  The ::popdown signal is a <link linkend="keybinding-signals">keybinding 
  788.    --  signal</link> which gets emitted to popdown the combo box list. 
  789.    -- 
  790.    --  The default bindings for this signal are Alt+Up and Escape. 
  791.  
  792.    Signal_Popup : constant Glib.Signal_Name := "popup"; 
  793.    procedure On_Popup 
  794.       (Self  : not null access Gtk_Combo_Box_Record; 
  795.        Call  : Cb_Gtk_Combo_Box_Void; 
  796.        After : Boolean := False); 
  797.    procedure On_Popup 
  798.       (Self  : not null access Gtk_Combo_Box_Record; 
  799.        Call  : Cb_GObject_Void; 
  800.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  801.        After : Boolean := False); 
  802.    --  The ::popup signal is a <link linkend="keybinding-signals">keybinding 
  803.    --  signal</link> which gets emitted to popup the combo box list. 
  804.    -- 
  805.    --  The default binding for this signal is Alt+Down. 
  806.  
  807.    ---------------- 
  808.    -- Interfaces -- 
  809.    ---------------- 
  810.    --  This class implements several interfaces. See Glib.Types 
  811.    -- 
  812.    --  - "Buildable" 
  813.    -- 
  814.    --  - "CellEditable" 
  815.    -- 
  816.    --  - "CellLayout" 
  817.  
  818.    package Implements_Gtk_Buildable is new Glib.Types.Implements 
  819.      (Gtk.Buildable.Gtk_Buildable, Gtk_Combo_Box_Record, Gtk_Combo_Box); 
  820.    function "+" 
  821.      (Widget : access Gtk_Combo_Box_Record'Class) 
  822.    return Gtk.Buildable.Gtk_Buildable 
  823.    renames Implements_Gtk_Buildable.To_Interface; 
  824.    function "-" 
  825.      (Interf : Gtk.Buildable.Gtk_Buildable) 
  826.    return Gtk_Combo_Box 
  827.    renames Implements_Gtk_Buildable.To_Object; 
  828.  
  829.    package Implements_Gtk_Cell_Editable is new Glib.Types.Implements 
  830.      (Gtk.Cell_Editable.Gtk_Cell_Editable, Gtk_Combo_Box_Record, Gtk_Combo_Box); 
  831.    function "+" 
  832.      (Widget : access Gtk_Combo_Box_Record'Class) 
  833.    return Gtk.Cell_Editable.Gtk_Cell_Editable 
  834.    renames Implements_Gtk_Cell_Editable.To_Interface; 
  835.    function "-" 
  836.      (Interf : Gtk.Cell_Editable.Gtk_Cell_Editable) 
  837.    return Gtk_Combo_Box 
  838.    renames Implements_Gtk_Cell_Editable.To_Object; 
  839.  
  840.    package Implements_Gtk_Cell_Layout is new Glib.Types.Implements 
  841.      (Gtk.Cell_Layout.Gtk_Cell_Layout, Gtk_Combo_Box_Record, Gtk_Combo_Box); 
  842.    function "+" 
  843.      (Widget : access Gtk_Combo_Box_Record'Class) 
  844.    return Gtk.Cell_Layout.Gtk_Cell_Layout 
  845.    renames Implements_Gtk_Cell_Layout.To_Interface; 
  846.    function "-" 
  847.      (Interf : Gtk.Cell_Layout.Gtk_Cell_Layout) 
  848.    return Gtk_Combo_Box 
  849.    renames Implements_Gtk_Cell_Layout.To_Object; 
  850.  
  851. private 
  852.    Wrap_Width_Property : constant Glib.Properties.Property_Int := 
  853.      Glib.Properties.Build ("wrap-width"); 
  854.    Tearoff_Title_Property : constant Glib.Properties.Property_String := 
  855.      Glib.Properties.Build ("tearoff-title"); 
  856.    Row_Span_Column_Property : constant Glib.Properties.Property_Int := 
  857.      Glib.Properties.Build ("row-span-column"); 
  858.    Popup_Shown_Property : constant Glib.Properties.Property_Boolean := 
  859.      Glib.Properties.Build ("popup-shown"); 
  860.    Popup_Fixed_Width_Property : constant Glib.Properties.Property_Boolean := 
  861.      Glib.Properties.Build ("popup-fixed-width"); 
  862.    Model_Property : constant Glib.Properties.Property_Interface := 
  863.      Glib.Properties.Build ("model"); 
  864.    Id_Column_Property : constant Glib.Properties.Property_Int := 
  865.      Glib.Properties.Build ("id-column"); 
  866.    Has_Frame_Property : constant Glib.Properties.Property_Boolean := 
  867.      Glib.Properties.Build ("has-frame"); 
  868.    Has_Entry_Property : constant Glib.Properties.Property_Boolean := 
  869.      Glib.Properties.Build ("has-entry"); 
  870.    Focus_On_Click_Property : constant Glib.Properties.Property_Boolean := 
  871.      Glib.Properties.Build ("focus-on-click"); 
  872.    Entry_Text_Column_Property : constant Glib.Properties.Property_Int := 
  873.      Glib.Properties.Build ("entry-text-column"); 
  874.    Column_Span_Column_Property : constant Glib.Properties.Property_Int := 
  875.      Glib.Properties.Build ("column-span-column"); 
  876.    Cell_Area_Property : constant Glib.Properties.Property_Object := 
  877.      Glib.Properties.Build ("cell-area"); 
  878.    Button_Sensitivity_Property : constant Gtk.Enums.Property_Gtk_Sensitivity_Type := 
  879.      Gtk.Enums.Build ("button-sensitivity"); 
  880.    Add_Tearoffs_Property : constant Glib.Properties.Property_Boolean := 
  881.      Glib.Properties.Build ("add-tearoffs"); 
  882.    Active_Id_Property : constant Glib.Properties.Property_String := 
  883.      Glib.Properties.Build ("active-id"); 
  884.    Active_Property : constant Glib.Properties.Property_Int := 
  885.      Glib.Properties.Build ("active"); 
  886. end Gtk.Combo_Box;