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 Gtk.Accel_Group.Gtk_Accel_Group represents a group of keyboard 
  26. --  accelerators, typically attached to a toplevel Gtk.Window.Gtk_Window (with 
  27. --  Gtk.Window.Add_Accel_Group). Usually you won't need to create a 
  28. --  Gtk.Accel_Group.Gtk_Accel_Group directly; instead, when using 
  29. --  Gtk.UI_Manager.Gtk_UI_Manager, GTK+ automatically sets up the accelerators 
  30. --  for your menus in the ui manager's Gtk.Accel_Group.Gtk_Accel_Group. 
  31. -- 
  32. --  Note that 'accelerators' are different from 'mnemonics'. Accelerators are 
  33. --  shortcuts for activating a menu item; they appear alongside the menu item 
  34. --  they're a shortcut for. For example "Ctrl+Q" might appear alongside the 
  35. --  "Quit" menu item. Mnemonics are shortcuts for GUI elements such as text 
  36. --  entries or buttons; they appear as underlined characters. See 
  37. --  Gtk.Label.Gtk_New_With_Mnemonic. Menu items can have both accelerators and 
  38. --  mnemonics, of course. 
  39. -- 
  40. --  </description> 
  41. pragma Ada_2005; 
  42.  
  43. pragma Warnings (Off, "*is already use-visible*"); 
  44. with Gdk.Types;               use Gdk.Types; 
  45. with Glib;                    use Glib; 
  46. with Glib.Generic_Properties; use Glib.Generic_Properties; 
  47. with Glib.Object;             use Glib.Object; 
  48. with Glib.Properties;         use Glib.Properties; 
  49.  
  50. package Gtk.Accel_Group is 
  51.  
  52.    type Gtk_Accel_Group_Record is new GObject_Record with null record; 
  53.    type Gtk_Accel_Group is access all Gtk_Accel_Group_Record'Class; 
  54.  
  55.    type Gtk_Accel_Flags is mod 2 ** Integer'Size; 
  56.    pragma Convention (C, Gtk_Accel_Flags); 
  57.  
  58.  
  59.    Accel_Visible : constant Gtk_Accel_Flags := 1; 
  60.    Accel_Locked : constant Gtk_Accel_Flags := 2; 
  61.    Accel_Mask : constant Gtk_Accel_Flags := 7; 
  62.  
  63.    type Gtk_Accel_Key is record 
  64.       Accel_Key : Gdk.Types.Gdk_Key_Type; 
  65.       Accel_Mods : Gdk.Types.Gdk_Modifier_Type; 
  66.       Accel_Flags : Gtk_Accel_Flags; 
  67.    end record; 
  68.    pragma Convention (C, Gtk_Accel_Key); 
  69.  
  70.    function From_Object_Free (B : access Gtk_Accel_Key) return Gtk_Accel_Key; 
  71.    pragma Inline (From_Object_Free); 
  72.  
  73.  
  74.    type Gtk_Accel_Group_Activate is access function 
  75.      (Accel_Group   : access Gtk_Accel_Group_Record'Class; 
  76.       Acceleratable : Glib.Object.GObject; 
  77.       Keyval        : Gdk.Types.Gdk_Key_Type; 
  78.       Modifier      : Gdk.Types.Gdk_Modifier_Type) return Boolean; 
  79.  
  80.    type C_Gtk_Accel_Group_Activate is access function 
  81.      (Accel_Group   : System.Address; 
  82.       Acceleratable : System.Address; 
  83.       Keyval        : Gdk.Types.Gdk_Key_Type; 
  84.       Modifier      : Gdk.Types.Gdk_Modifier_Type) return Boolean; 
  85.    pragma Convention (C, C_Gtk_Accel_Group_Activate); 
  86.    --  Same as Gtk_Accel_Group_Activate, but passing directly the C values. 
  87.    --  You must use Get_User_Data to convert to the Ada types. 
  88.  
  89.    --------------- 
  90.    -- Callbacks -- 
  91.    --------------- 
  92.  
  93.    type Gtk_Accel_Group_Find_Func is access function 
  94.      (Key     : Gtk_Accel_Key; 
  95.       Closure : System.Address) return Boolean; 
  96.    --  Since: gtk+ 2.2 
  97.  
  98.    ---------------------------- 
  99.    -- Enumeration Properties -- 
  100.    ---------------------------- 
  101.  
  102.    package Gtk_Accel_Flags_Properties is 
  103.       new Generic_Internal_Discrete_Property (Gtk_Accel_Flags); 
  104.    type Property_Gtk_Accel_Flags is new Gtk_Accel_Flags_Properties.Property; 
  105.  
  106.    ------------------ 
  107.    -- Constructors -- 
  108.    ------------------ 
  109.  
  110.    procedure Gtk_New (Accel_Group : out Gtk_Accel_Group); 
  111.    procedure Initialize 
  112.       (Accel_Group : not null access Gtk_Accel_Group_Record'Class); 
  113.    --  Creates a new Gtk.Accel_Group.Gtk_Accel_Group. Remember to call 
  114.    --  Gtk.Window.Add_Accel_Group to active the group. 
  115.  
  116.    function Gtk_Accel_Group_New return Gtk_Accel_Group; 
  117.    --  Creates a new Gtk.Accel_Group.Gtk_Accel_Group. Remember to call 
  118.    --  Gtk.Window.Add_Accel_Group to active the group. 
  119.  
  120.    function Get_Type return Glib.GType; 
  121.    pragma Import (C, Get_Type, "gtk_accel_group_get_type"); 
  122.  
  123.    ------------- 
  124.    -- Methods -- 
  125.    ------------- 
  126.  
  127.    function Activate 
  128.       (Accel_Group   : not null access Gtk_Accel_Group_Record; 
  129.        Accel_Quark   : Glib.GQuark; 
  130.        Acceleratable : not null access Glib.Object.GObject_Record'Class; 
  131.        Accel_Key     : Guint; 
  132.        Accel_Mods    : Gdk.Types.Gdk_Modifier_Type) return Boolean; 
  133.    --  Finds the first accelerator in Accel_Group that matches Accel_Key and 
  134.    --  Accel_Mods, and activates it. 
  135.    --  "accel_quark": the quark for the accelerator name 
  136.    --  "acceleratable": the Glib.Object.GObject, usually a 
  137.    --  Gtk.Window.Gtk_Window, on which to activate the accelerator 
  138.    --  "accel_key": accelerator keyval from a key event 
  139.    --  "accel_mods": keyboard state mask from a key event 
  140.  
  141.    procedure Connect 
  142.       (Accel_Group : not null access Gtk_Accel_Group_Record; 
  143.        Accel_Key   : Guint; 
  144.        Accel_Mods  : Gdk.Types.Gdk_Modifier_Type; 
  145.        Accel_Flags : Gtk_Accel_Flags; 
  146.        Closure     : C_Gtk_Accel_Group_Activate); 
  147.    --  Installs an accelerator in this group. When Accel_Group is being 
  148.    --  activated in response to a call to 
  149.    --  Gtk.Accel_Group.Accel_Groups_Activate, Closure will be invoked if the 
  150.    --  Accel_Key and Accel_Mods from Gtk.Accel_Group.Accel_Groups_Activate 
  151.    --  match those of this connection. 
  152.    --  The signature used for the Closure is that of Gtk_Accel_Group_Activate. 
  153.    --  Note that, due to implementation details, a single closure can only be 
  154.    --  connected to one accelerator group. 
  155.    --  "accel_key": key value of the accelerator 
  156.    --  "accel_mods": modifier combination of the accelerator 
  157.    --  "accel_flags": a flag mask to configure this accelerator 
  158.    --  "closure": closure to be executed upon accelerator activation 
  159.  
  160.    procedure Connect_By_Path 
  161.       (Accel_Group : not null access Gtk_Accel_Group_Record; 
  162.        Accel_Path  : UTF8_String; 
  163.        Closure     : C_Gtk_Accel_Group_Activate); 
  164.    --  Installs an accelerator in this group, using an accelerator path to 
  165.    --  look up the appropriate key and modifiers (see Gtk.Accel_Map.Add_Entry). 
  166.    --  When Accel_Group is being activated in response to a call to 
  167.    --  Gtk.Accel_Group.Accel_Groups_Activate, Closure will be invoked if the 
  168.    --  Accel_Key and Accel_Mods from Gtk.Accel_Group.Accel_Groups_Activate 
  169.    --  match the key and modifiers for the path. 
  170.    --  The signature used for the Closure is that of Gtk_Accel_Group_Activate. 
  171.    --  Note that Accel_Path string will be stored in a Glib.GQuark. Therefore, 
  172.    --  if you pass a static string, you can save some memory by interning it 
  173.    --  first with g_intern_static_string. 
  174.    --  "accel_path": path used for determining key and modifiers 
  175.    --  "closure": closure to be executed upon accelerator activation 
  176.  
  177.    function Disconnect 
  178.       (Accel_Group : not null access Gtk_Accel_Group_Record; 
  179.        Closure     : C_Gtk_Accel_Group_Activate) return Boolean; 
  180.    --  Removes an accelerator previously installed through 
  181.    --  Gtk.Accel_Group.Connect. 
  182.    --  Since 2.20 Closure can be null. 
  183.    --  "closure": the closure to remove from this accelerator group, or null 
  184.    --  to remove all closures 
  185.  
  186.    function Disconnect_Key 
  187.       (Accel_Group : not null access Gtk_Accel_Group_Record; 
  188.        Accel_Key   : Guint; 
  189.        Accel_Mods  : Gdk.Types.Gdk_Modifier_Type) return Boolean; 
  190.    --  Removes an accelerator previously installed through 
  191.    --  Gtk.Accel_Group.Connect. 
  192.    --  "accel_key": key value of the accelerator 
  193.    --  "accel_mods": modifier combination of the accelerator 
  194.  
  195.    function Find 
  196.       (Accel_Group : not null access Gtk_Accel_Group_Record; 
  197.        Find_Func   : Gtk_Accel_Group_Find_Func) return Gtk_Accel_Key; 
  198.    --  Finds the first entry in an accelerator group for which Find_Func 
  199.    --  returns True and returns its Gtk.Accel_Group.Gtk_Accel_Key. 
  200.    --  "find_func": a function to filter the entries of Accel_Group with 
  201.  
  202.    generic 
  203.       type User_Data_Type (<>) is private; 
  204.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  205.    package Find_User_Data is 
  206.  
  207.       type Gtk_Accel_Group_Find_Func is access function 
  208.         (Key     : Gtk.Accel_Group.Gtk_Accel_Key; 
  209.          Closure : System.Address; 
  210.          Data    : User_Data_Type) return Boolean; 
  211.       --  Since: gtk+ 2.2 
  212.  
  213.       function Find 
  214.          (Accel_Group : not null access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class; 
  215.           Find_Func   : Gtk_Accel_Group_Find_Func; 
  216.           Data        : User_Data_Type) return Gtk.Accel_Group.Gtk_Accel_Key; 
  217.       --  Finds the first entry in an accelerator group for which Find_Func 
  218.       --  returns True and returns its Gtk.Accel_Group.Gtk_Accel_Key. 
  219.       --  "find_func": a function to filter the entries of Accel_Group with 
  220.       --  "data": data to pass to Find_Func 
  221.  
  222.    end Find_User_Data; 
  223.  
  224.    function Get_Is_Locked 
  225.       (Accel_Group : not null access Gtk_Accel_Group_Record) return Boolean; 
  226.    --  Locks are added and removed using Gtk.Accel_Group.Lock and 
  227.    --  Gtk.Accel_Group.Unlock. 
  228.    --  Since: gtk+ 2.14 
  229.  
  230.    function Get_Modifier_Mask 
  231.       (Accel_Group : not null access Gtk_Accel_Group_Record) 
  232.        return Gdk.Types.Gdk_Modifier_Type; 
  233.    --  Gets a Gdk.Types.Gdk_Modifier_Type representing the mask for this 
  234.    --  Accel_Group. For example, GDK_CONTROL_MASK, GDK_SHIFT_MASK, etc. 
  235.    --  Since: gtk+ 2.14 
  236.  
  237.    procedure Lock (Accel_Group : not null access Gtk_Accel_Group_Record); 
  238.    --  Locks the given accelerator group. 
  239.    --  Locking an acelerator group prevents the accelerators contained within 
  240.    --  it to be changed during runtime. Refer to Gtk.Accel_Map.Change_Entry 
  241.    --  about runtime accelerator changes. 
  242.    --  If called more than once, Accel_Group remains locked until 
  243.    --  Gtk.Accel_Group.Unlock has been called an equivalent number of times. 
  244.  
  245.    procedure Unlock (Accel_Group : not null access Gtk_Accel_Group_Record); 
  246.    --  Undoes the last call to Gtk.Accel_Group.Lock on this Accel_Group. 
  247.  
  248.    --------------- 
  249.    -- Functions -- 
  250.    --------------- 
  251.  
  252.    function From_Accel_Closure 
  253.       (Closure : C_Gtk_Accel_Group_Activate) return Gtk_Accel_Group; 
  254.    --  Finds the Gtk.Accel_Group.Gtk_Accel_Group to which Closure is 
  255.    --  connected; see Gtk.Accel_Group.Connect. 
  256.    --  "closure": a GClosure 
  257.  
  258.    function Accel_Groups_Activate 
  259.       (Object     : not null access Glib.Object.GObject_Record'Class; 
  260.        Accel_Key  : Gdk.Types.Gdk_Key_Type; 
  261.        Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Boolean; 
  262.    --  Finds the first accelerator in any Gtk.Accel_Group.Gtk_Accel_Group 
  263.    --  attached to Object that matches Accel_Key and Accel_Mods, and activates 
  264.    --  that accelerator. 
  265.    --  "object": the Glib.Object.GObject, usually a Gtk.Window.Gtk_Window, on 
  266.    --  which to activate the accelerator 
  267.    --  "accel_key": accelerator keyval from a key event 
  268.    --  "accel_mods": keyboard state mask from a key event 
  269.  
  270.    function From_Object 
  271.       (Object : not null access Glib.Object.GObject_Record'Class) 
  272.        return Glib.Object.Object_List.GSlist; 
  273.    --  Gets a list of all accel groups which are attached to Object. 
  274.    --  "object": a Glib.Object.GObject, usually a Gtk.Window.Gtk_Window 
  275.  
  276.    function Accelerator_Valid 
  277.       (Keyval    : Gdk.Types.Gdk_Key_Type; 
  278.        Modifiers : Gdk.Types.Gdk_Modifier_Type) return Boolean; 
  279.    --  Determines whether a given keyval and modifier mask constitute a valid 
  280.    --  keyboard accelerator. For example, the GDK_KEY_a keyval plus 
  281.    --  GDK_CONTROL_MASK is valid - this is a "Ctrl+a" accelerator. But, you 
  282.    --  can't, for instance, use the GDK_KEY_Control_L keyval as an accelerator. 
  283.    --  "keyval": a GDK keyval 
  284.    --  "modifiers": modifier mask 
  285.  
  286.    procedure Accelerator_Parse 
  287.       (Accelerator      : UTF8_String; 
  288.        Accelerator_Key  : out Gdk.Types.Gdk_Key_Type; 
  289.        Accelerator_Mods : out Gdk.Types.Gdk_Modifier_Type); 
  290.    --  Parses a string representing an accelerator. The format looks like 
  291.    --  "<Control>a" or "<Shift><Alt>F1" or "<Release>z" (the last one is for 
  292.    --  key release). 
  293.    --  The parser is fairly liberal and allows lower or upper case, and also 
  294.    --  abbreviations such as "<Ctl>" and "<Ctrl>". Key names are parsed using 
  295.    --  gdk_keyval_from_name. For character keys the name is not the symbol, but 
  296.    --  the lowercase name, e.g. one would use "<Ctrl>minus" instead of 
  297.    --  "<Ctrl>-". 
  298.    --  If the parse fails, Accelerator_Key and Accelerator_Mods will be set to 
  299.    --  0 (zero). 
  300.    --  "accelerator": string representing an accelerator 
  301.    --  "accelerator_key": return location for accelerator keyval, or null 
  302.    --  "accelerator_mods": return location for accelerator modifier mask, null 
  303.  
  304.    function Accelerator_Name 
  305.       (Accelerator_Key  : Gdk.Types.Gdk_Key_Type; 
  306.        Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type) return UTF8_String; 
  307.    --  Converts an accelerator keyval and modifier mask into a string 
  308.    --  parseable by Gtk.Accel_Group.Accelerator_Parse. For example, if you pass 
  309.    --  in GDK_KEY_q and GDK_CONTROL_MASK, this function returns "<Control>q". 
  310.    --  If you need to display accelerators in the user interface, see 
  311.    --  Gtk.Accel_Group.Accelerator_Get_Label. 
  312.    --  "accelerator_key": accelerator keyval 
  313.    --  "accelerator_mods": accelerator modifier mask 
  314.  
  315.    function Accelerator_Get_Label 
  316.       (Accelerator_Key  : Gdk.Types.Gdk_Key_Type; 
  317.        Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type) return UTF8_String; 
  318.    --  Converts an accelerator keyval and modifier mask into a string which 
  319.    --  can be used to represent the accelerator to the user. 
  320.    --  Since: gtk+ 2.6 
  321.    --  "accelerator_key": accelerator keyval 
  322.    --  "accelerator_mods": accelerator modifier mask 
  323.  
  324.    procedure Set_Default_Mod_Mask 
  325.       (Default_Mod_Mask : Gdk.Types.Gdk_Modifier_Type); 
  326.    --  Sets the modifiers that will be considered significant for keyboard 
  327.    --  accelerators. The default mod mask is GDK_CONTROL_MASK | GDK_SHIFT_MASK 
  328.    --  | GDK_MOD1_MASK | GDK_SUPER_MASK | GDK_HYPER_MASK | GDK_META_MASK, that 
  329.    --  is, Control, Shift, Alt, Super, Hyper and Meta. Other modifiers will by 
  330.    --  default be ignored by Gtk.Accel_Group.Gtk_Accel_Group. You must include 
  331.    --  at least the three modifiers Control, Shift and Alt in any value you 
  332.    --  pass to this function. 
  333.    --  The default mod mask should be changed on application startup, before 
  334.    --  using any accelerator groups. 
  335.    --  "default_mod_mask": accelerator modifier mask 
  336.  
  337.    function Get_Default_Mod_Mask return Gdk.Types.Gdk_Modifier_Type; 
  338.    --  Gets the value set by Gtk.Accel_Group.Set_Default_Mod_Mask. 
  339.  
  340.    ---------------- 
  341.    -- Properties -- 
  342.    ---------------- 
  343.    --  The following properties are defined for this widget. See 
  344.    --  Glib.Properties for more information on properties) 
  345.  
  346.    Is_Locked_Property : constant Glib.Properties.Property_Boolean; 
  347.  
  348.    Modifier_Mask_Property : constant Glib.Properties.Property_Boxed; 
  349.    --  Type: Gdk.Types.Gdk_Modifier_Type 
  350.  
  351.    ------------- 
  352.    -- Signals -- 
  353.    ------------- 
  354.  
  355.    type Cb_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean is not null access function 
  356.      (Self          : access Gtk_Accel_Group_Record'Class; 
  357.       Acceleratable : not null access Glib.Object.GObject_Record'Class; 
  358.       Keyval        : Guint; 
  359.       Modifier      : Gdk.Types.Gdk_Modifier_Type) return Boolean; 
  360.  
  361.    type Cb_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean is not null access function 
  362.      (Self          : access Glib.Object.GObject_Record'Class; 
  363.       Acceleratable : not null access Glib.Object.GObject_Record'Class; 
  364.       Keyval        : Guint; 
  365.       Modifier      : Gdk.Types.Gdk_Modifier_Type) return Boolean; 
  366.  
  367.    Signal_Accel_Activate : constant Glib.Signal_Name := "accel-activate"; 
  368.    procedure On_Accel_Activate 
  369.       (Self  : not null access Gtk_Accel_Group_Record; 
  370.        Call  : Cb_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean; 
  371.        After : Boolean := False); 
  372.    procedure On_Accel_Activate 
  373.       (Self  : not null access Gtk_Accel_Group_Record; 
  374.        Call  : Cb_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean; 
  375.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  376.        After : Boolean := False); 
  377.    --  The accel-activate signal is an implementation detail of 
  378.    --  Gtk.Accel_Group.Gtk_Accel_Group and not meant to be used by 
  379.    --  applications. 
  380.    --  
  381.    --  Callback parameters: 
  382.    --    --  "acceleratable": the object on which the accelerator was activated 
  383.    --    --  "keyval": the accelerator keyval 
  384.    --    --  "modifier": the modifier combination of the accelerator 
  385.    --    --  Returns True if the accelerator was activated 
  386.  
  387.    type Cb_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void is not null access procedure 
  388.      (Self          : access Gtk_Accel_Group_Record'Class; 
  389.       Keyval        : Guint; 
  390.       Modifier      : Gdk.Types.Gdk_Modifier_Type; 
  391.       Accel_Closure : System.Address); 
  392.  
  393.    type Cb_GObject_Guint_Gdk_Modifier_Type_Address_Void is not null access procedure 
  394.      (Self          : access Glib.Object.GObject_Record'Class; 
  395.       Keyval        : Guint; 
  396.       Modifier      : Gdk.Types.Gdk_Modifier_Type; 
  397.       Accel_Closure : System.Address); 
  398.  
  399.    Signal_Accel_Changed : constant Glib.Signal_Name := "accel-changed"; 
  400.    procedure On_Accel_Changed 
  401.       (Self  : not null access Gtk_Accel_Group_Record; 
  402.        Call  : Cb_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void; 
  403.        After : Boolean := False); 
  404.    procedure On_Accel_Changed 
  405.       (Self  : not null access Gtk_Accel_Group_Record; 
  406.        Call  : Cb_GObject_Guint_Gdk_Modifier_Type_Address_Void; 
  407.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  408.        After : Boolean := False); 
  409.    --  The accel-changed signal is emitted when an entry is added to or 
  410.    --  removed from the accel group. 
  411.    -- 
  412.    --  Widgets like Gtk.Accel_Label.Gtk_Accel_Label which display an 
  413.    --  associated accelerator should connect to this signal, and rebuild their 
  414.    --  visual representation if the Accel_Closure is theirs. 
  415.    --  
  416.    --  Callback parameters: 
  417.    --    --  "keyval": the accelerator keyval 
  418.    --    --  "modifier": the modifier combination of the accelerator 
  419.    --    --  "accel_closure": the GClosure of the accelerator 
  420.  
  421. private 
  422.    Modifier_Mask_Property : constant Glib.Properties.Property_Boxed := 
  423.      Glib.Properties.Build ("modifier-mask"); 
  424.    Is_Locked_Property : constant Glib.Properties.Property_Boolean := 
  425.      Glib.Properties.Build ("is-locked"); 
  426. end Gtk.Accel_Group;