------------------------------------------------------------------------------
-- --
-- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet --
-- Copyright (C) 2000-2014, AdaCore --
-- --
-- This library is free software; you can redistribute it and/or modify it --
-- under terms of the GNU General Public License as published by the Free --
-- Software Foundation; either version 3, or (at your option) any later --
-- version. This library is distributed in the hope that it will be useful, --
-- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- --
-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
------------------------------------------------------------------------------
-- <description>
-- A Gtk.Accel_Group.Gtk_Accel_Group represents a group of keyboard
-- accelerators, typically attached to a toplevel Gtk.Window.Gtk_Window (with
-- Gtk.Window.Add_Accel_Group). Usually you won't need to create a
-- Gtk.Accel_Group.Gtk_Accel_Group directly; instead, when using
-- Gtk.UI_Manager.Gtk_UI_Manager, GTK+ automatically sets up the accelerators
-- for your menus in the ui manager's Gtk.Accel_Group.Gtk_Accel_Group.
--
-- Note that 'accelerators' are different from 'mnemonics'. Accelerators are
-- shortcuts for activating a menu item; they appear alongside the menu item
-- they're a shortcut for. For example "Ctrl+Q" might appear alongside the
-- "Quit" menu item. Mnemonics are shortcuts for GUI elements such as text
-- entries or buttons; they appear as underlined characters. See
-- Gtk.Label.Gtk_New_With_Mnemonic. Menu items can have both accelerators and
-- mnemonics, of course.
--
-- </description>
pragma Ada_2005;
pragma Warnings (Off, "*is already use-visible*");
with Gdk.Types; use Gdk.Types;
with Glib; use Glib;
with Glib.Generic_Properties; use Glib.Generic_Properties;
with Glib.Object; use Glib.Object;
with Glib.Properties; use Glib.Properties;
package Gtk.Accel_Group is
type Gtk_Accel_Group_Record is new GObject_Record with null record;
type Gtk_Accel_Group is access all Gtk_Accel_Group_Record'Class;
type Gtk_Accel_Flags is mod 2 ** Integer'Size;
pragma Convention (C, Gtk_Accel_Flags);
Accel_Visible : constant Gtk_Accel_Flags := 1;
Accel_Locked : constant Gtk_Accel_Flags := 2;
Accel_Mask : constant Gtk_Accel_Flags := 7;
type Gtk_Accel_Key is record
Accel_Key : Gdk.Types.Gdk_Key_Type;
Accel_Mods : Gdk.Types.Gdk_Modifier_Type;
Accel_Flags : Gtk_Accel_Flags;
end record;
pragma Convention (C, Gtk_Accel_Key);
function From_Object_Free (B : access Gtk_Accel_Key) return Gtk_Accel_Key;
pragma Inline (From_Object_Free);
type Gtk_Accel_Group_Activate is access function
(Accel_Group : access Gtk_Accel_Group_Record'Class;
Acceleratable : Glib.Object.GObject;
Keyval : Gdk.Types.Gdk_Key_Type;
Modifier : Gdk.Types.Gdk_Modifier_Type) return Boolean;
type C_Gtk_Accel_Group_Activate is access function
(Accel_Group : System.Address;
Acceleratable : System.Address;
Keyval : Gdk.Types.Gdk_Key_Type;
Modifier : Gdk.Types.Gdk_Modifier_Type) return Boolean;
pragma Convention (C, C_Gtk_Accel_Group_Activate);
-- Same as Gtk_Accel_Group_Activate, but passing directly the C values.
-- You must use Get_User_Data to convert to the Ada types.
---------------
-- Callbacks --
---------------
type Gtk_Accel_Group_Find_Func is access function
(Key : Gtk_Accel_Key;
Closure : System.Address) return Boolean;
-- Since: gtk+ 2.2
----------------------------
-- Enumeration Properties --
----------------------------
package Gtk_Accel_Flags_Properties is
new Generic_Internal_Discrete_Property (Gtk_Accel_Flags);
type Property_Gtk_Accel_Flags is new Gtk_Accel_Flags_Properties.Property;
------------------
-- Constructors --
------------------
procedure Gtk_New (Accel_Group : out Gtk_Accel_Group);
procedure Initialize
(Accel_Group : not null access Gtk_Accel_Group_Record'Class);
-- Creates a new Gtk.Accel_Group.Gtk_Accel_Group. Remember to call
-- Gtk.Window.Add_Accel_Group to active the group.
function Gtk_Accel_Group_New return Gtk_Accel_Group;
-- Creates a new Gtk.Accel_Group.Gtk_Accel_Group. Remember to call
-- Gtk.Window.Add_Accel_Group to active the group.
function Get_Type return Glib.GType;
pragma Import (C, Get_Type, "gtk_accel_group_get_type");
-------------
-- Methods --
-------------
function Activate
(Accel_Group : not null access Gtk_Accel_Group_Record;
Accel_Quark : Glib.GQuark;
Acceleratable : not null access Glib.Object.GObject_Record'Class;
Accel_Key : Guint;
Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Boolean;
-- Finds the first accelerator in Accel_Group that matches Accel_Key and
-- Accel_Mods, and activates it.
-- "accel_quark": the quark for the accelerator name
-- "acceleratable": the Glib.Object.GObject, usually a
-- Gtk.Window.Gtk_Window, on which to activate the accelerator
-- "accel_key": accelerator keyval from a key event
-- "accel_mods": keyboard state mask from a key event
procedure Connect
(Accel_Group : not null access Gtk_Accel_Group_Record;
Accel_Key : Guint;
Accel_Mods : Gdk.Types.Gdk_Modifier_Type;
Accel_Flags : Gtk_Accel_Flags;
Closure : C_Gtk_Accel_Group_Activate);
-- Installs an accelerator in this group. When Accel_Group is being
-- activated in response to a call to
-- Gtk.Accel_Group.Accel_Groups_Activate, Closure will be invoked if the
-- Accel_Key and Accel_Mods from Gtk.Accel_Group.Accel_Groups_Activate
-- match those of this connection.
-- The signature used for the Closure is that of Gtk_Accel_Group_Activate.
-- Note that, due to implementation details, a single closure can only be
-- connected to one accelerator group.
-- "accel_key": key value of the accelerator
-- "accel_mods": modifier combination of the accelerator
-- "accel_flags": a flag mask to configure this accelerator
-- "closure": closure to be executed upon accelerator activation
procedure Connect_By_Path
(Accel_Group : not null access Gtk_Accel_Group_Record;
Accel_Path : UTF8_String;
Closure : C_Gtk_Accel_Group_Activate);
-- Installs an accelerator in this group, using an accelerator path to
-- look up the appropriate key and modifiers (see Gtk.Accel_Map.Add_Entry).
-- When Accel_Group is being activated in response to a call to
-- Gtk.Accel_Group.Accel_Groups_Activate, Closure will be invoked if the
-- Accel_Key and Accel_Mods from Gtk.Accel_Group.Accel_Groups_Activate
-- match the key and modifiers for the path.
-- The signature used for the Closure is that of Gtk_Accel_Group_Activate.
-- Note that Accel_Path string will be stored in a Glib.GQuark. Therefore,
-- if you pass a static string, you can save some memory by interning it
-- first with g_intern_static_string.
-- "accel_path": path used for determining key and modifiers
-- "closure": closure to be executed upon accelerator activation
function Disconnect
(Accel_Group : not null access Gtk_Accel_Group_Record;
Closure : C_Gtk_Accel_Group_Activate) return Boolean;
-- Removes an accelerator previously installed through
-- Gtk.Accel_Group.Connect.
-- Since 2.20 Closure can be null.
-- "closure": the closure to remove from this accelerator group, or null
-- to remove all closures
function Disconnect_Key
(Accel_Group : not null access Gtk_Accel_Group_Record;
Accel_Key : Guint;
Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Boolean;
-- Removes an accelerator previously installed through
-- Gtk.Accel_Group.Connect.
-- "accel_key": key value of the accelerator
-- "accel_mods": modifier combination of the accelerator
function Find
(Accel_Group : not null access Gtk_Accel_Group_Record;
Find_Func : Gtk_Accel_Group_Find_Func) return Gtk_Accel_Key;
-- Finds the first entry in an accelerator group for which Find_Func
-- returns True and returns its Gtk.Accel_Group.Gtk_Accel_Key.
-- "find_func": a function to filter the entries of Accel_Group with
generic
type User_Data_Type (<>) is private;
with procedure Destroy (Data : in out User_Data_Type) is null;
package Find_User_Data is
type Gtk_Accel_Group_Find_Func is access function
(Key : Gtk.Accel_Group.Gtk_Accel_Key;
Closure : System.Address;
Data : User_Data_Type) return Boolean;
-- Since: gtk+ 2.2
function Find
(Accel_Group : not null access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class;
Find_Func : Gtk_Accel_Group_Find_Func;
Data : User_Data_Type) return Gtk.Accel_Group.Gtk_Accel_Key;
-- Finds the first entry in an accelerator group for which Find_Func
-- returns True and returns its Gtk.Accel_Group.Gtk_Accel_Key.
-- "find_func": a function to filter the entries of Accel_Group with
-- "data": data to pass to Find_Func
end Find_User_Data;
function Get_Is_Locked
(Accel_Group : not null access Gtk_Accel_Group_Record) return Boolean;
-- Locks are added and removed using Gtk.Accel_Group.Lock and
-- Gtk.Accel_Group.Unlock.
-- Since: gtk+ 2.14
function Get_Modifier_Mask
(Accel_Group : not null access Gtk_Accel_Group_Record)
return Gdk.Types.Gdk_Modifier_Type;
-- Gets a Gdk.Types.Gdk_Modifier_Type representing the mask for this
-- Accel_Group. For example, GDK_CONTROL_MASK, GDK_SHIFT_MASK, etc.
-- Since: gtk+ 2.14
procedure Lock (Accel_Group : not null access Gtk_Accel_Group_Record);
-- Locks the given accelerator group.
-- Locking an acelerator group prevents the accelerators contained within
-- it to be changed during runtime. Refer to Gtk.Accel_Map.Change_Entry
-- about runtime accelerator changes.
-- If called more than once, Accel_Group remains locked until
-- Gtk.Accel_Group.Unlock has been called an equivalent number of times.
procedure Unlock (Accel_Group : not null access Gtk_Accel_Group_Record);
-- Undoes the last call to Gtk.Accel_Group.Lock on this Accel_Group.
---------------
-- Functions --
---------------
function From_Accel_Closure
(Closure : C_Gtk_Accel_Group_Activate) return Gtk_Accel_Group;
-- Finds the Gtk.Accel_Group.Gtk_Accel_Group to which Closure is
-- connected; see Gtk.Accel_Group.Connect.
-- "closure": a GClosure
function Accel_Groups_Activate
(Object : not null access Glib.Object.GObject_Record'Class;
Accel_Key : Gdk.Types.Gdk_Key_Type;
Accel_Mods : Gdk.Types.Gdk_Modifier_Type) return Boolean;
-- Finds the first accelerator in any Gtk.Accel_Group.Gtk_Accel_Group
-- attached to Object that matches Accel_Key and Accel_Mods, and activates
-- that accelerator.
-- "object": the Glib.Object.GObject, usually a Gtk.Window.Gtk_Window, on
-- which to activate the accelerator
-- "accel_key": accelerator keyval from a key event
-- "accel_mods": keyboard state mask from a key event
function From_Object
(Object : not null access Glib.Object.GObject_Record'Class)
return Glib.Object.Object_List.GSlist;
-- Gets a list of all accel groups which are attached to Object.
-- "object": a Glib.Object.GObject, usually a Gtk.Window.Gtk_Window
function Accelerator_Valid
(Keyval : Gdk.Types.Gdk_Key_Type;
Modifiers : Gdk.Types.Gdk_Modifier_Type) return Boolean;
-- Determines whether a given keyval and modifier mask constitute a valid
-- keyboard accelerator. For example, the GDK_KEY_a keyval plus
-- GDK_CONTROL_MASK is valid - this is a "Ctrl+a" accelerator. But, you
-- can't, for instance, use the GDK_KEY_Control_L keyval as an accelerator.
-- "keyval": a GDK keyval
-- "modifiers": modifier mask
procedure Accelerator_Parse
(Accelerator : UTF8_String;
Accelerator_Key : out Gdk.Types.Gdk_Key_Type;
Accelerator_Mods : out Gdk.Types.Gdk_Modifier_Type);
-- Parses a string representing an accelerator. The format looks like
-- "<Control>a" or "<Shift><Alt>F1" or "<Release>z" (the last one is for
-- key release).
-- The parser is fairly liberal and allows lower or upper case, and also
-- abbreviations such as "<Ctl>" and "<Ctrl>". Key names are parsed using
-- gdk_keyval_from_name. For character keys the name is not the symbol, but
-- the lowercase name, e.g. one would use "<Ctrl>minus" instead of
-- "<Ctrl>-".
-- If the parse fails, Accelerator_Key and Accelerator_Mods will be set to
-- 0 (zero).
-- "accelerator": string representing an accelerator
-- "accelerator_key": return location for accelerator keyval, or null
-- "accelerator_mods": return location for accelerator modifier mask, null
function Accelerator_Name
(Accelerator_Key : Gdk.Types.Gdk_Key_Type;
Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type) return UTF8_String;
-- Converts an accelerator keyval and modifier mask into a string
-- parseable by Gtk.Accel_Group.Accelerator_Parse. For example, if you pass
-- in GDK_KEY_q and GDK_CONTROL_MASK, this function returns "<Control>q".
-- If you need to display accelerators in the user interface, see
-- Gtk.Accel_Group.Accelerator_Get_Label.
-- "accelerator_key": accelerator keyval
-- "accelerator_mods": accelerator modifier mask
function Accelerator_Get_Label
(Accelerator_Key : Gdk.Types.Gdk_Key_Type;
Accelerator_Mods : Gdk.Types.Gdk_Modifier_Type) return UTF8_String;
-- Converts an accelerator keyval and modifier mask into a string which
-- can be used to represent the accelerator to the user.
-- Since: gtk+ 2.6
-- "accelerator_key": accelerator keyval
-- "accelerator_mods": accelerator modifier mask
procedure Set_Default_Mod_Mask
(Default_Mod_Mask : Gdk.Types.Gdk_Modifier_Type);
-- Sets the modifiers that will be considered significant for keyboard
-- accelerators. The default mod mask is GDK_CONTROL_MASK | GDK_SHIFT_MASK
-- | GDK_MOD1_MASK | GDK_SUPER_MASK | GDK_HYPER_MASK | GDK_META_MASK, that
-- is, Control, Shift, Alt, Super, Hyper and Meta. Other modifiers will by
-- default be ignored by Gtk.Accel_Group.Gtk_Accel_Group. You must include
-- at least the three modifiers Control, Shift and Alt in any value you
-- pass to this function.
-- The default mod mask should be changed on application startup, before
-- using any accelerator groups.
-- "default_mod_mask": accelerator modifier mask
function Get_Default_Mod_Mask return Gdk.Types.Gdk_Modifier_Type;
-- Gets the value set by Gtk.Accel_Group.Set_Default_Mod_Mask.
----------------
-- Properties --
----------------
-- The following properties are defined for this widget. See
-- Glib.Properties for more information on properties)
Is_Locked_Property : constant Glib.Properties.Property_Boolean;
Modifier_Mask_Property : constant Glib.Properties.Property_Boxed;
-- Type: Gdk.Types.Gdk_Modifier_Type
-------------
-- Signals --
-------------
type Cb_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean is not null access function
(Self : access Gtk_Accel_Group_Record'Class;
Acceleratable : not null access Glib.Object.GObject_Record'Class;
Keyval : Guint;
Modifier : Gdk.Types.Gdk_Modifier_Type) return Boolean;
type Cb_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean is not null access function
(Self : access Glib.Object.GObject_Record'Class;
Acceleratable : not null access Glib.Object.GObject_Record'Class;
Keyval : Guint;
Modifier : Gdk.Types.Gdk_Modifier_Type) return Boolean;
Signal_Accel_Activate : constant Glib.Signal_Name := "accel-activate";
procedure On_Accel_Activate
(Self : not null access Gtk_Accel_Group_Record;
Call : Cb_Gtk_Accel_Group_GObject_Guint_Gdk_Modifier_Type_Boolean;
After : Boolean := False);
procedure On_Accel_Activate
(Self : not null access Gtk_Accel_Group_Record;
Call : Cb_GObject_GObject_Guint_Gdk_Modifier_Type_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The accel-activate signal is an implementation detail of
-- Gtk.Accel_Group.Gtk_Accel_Group and not meant to be used by
-- applications.
--
-- Callback parameters:
-- -- "acceleratable": the object on which the accelerator was activated
-- -- "keyval": the accelerator keyval
-- -- "modifier": the modifier combination of the accelerator
-- -- Returns True if the accelerator was activated
type Cb_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void is not null access procedure
(Self : access Gtk_Accel_Group_Record'Class;
Keyval : Guint;
Modifier : Gdk.Types.Gdk_Modifier_Type;
Accel_Closure : System.Address);
type Cb_GObject_Guint_Gdk_Modifier_Type_Address_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Keyval : Guint;
Modifier : Gdk.Types.Gdk_Modifier_Type;
Accel_Closure : System.Address);
Signal_Accel_Changed : constant Glib.Signal_Name := "accel-changed";
procedure On_Accel_Changed
(Self : not null access Gtk_Accel_Group_Record;
Call : Cb_Gtk_Accel_Group_Guint_Gdk_Modifier_Type_Address_Void;
After : Boolean := False);
procedure On_Accel_Changed
(Self : not null access Gtk_Accel_Group_Record;
Call : Cb_GObject_Guint_Gdk_Modifier_Type_Address_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The accel-changed signal is emitted when an entry is added to or
-- removed from the accel group.
--
-- Widgets like Gtk.Accel_Label.Gtk_Accel_Label which display an
-- associated accelerator should connect to this signal, and rebuild their
-- visual representation if the Accel_Closure is theirs.
--
-- Callback parameters:
-- -- "keyval": the accelerator keyval
-- -- "modifier": the modifier combination of the accelerator
-- -- "accel_closure": the GClosure of the accelerator
private
Modifier_Mask_Property : constant Glib.Properties.Property_Boxed :=
Glib.Properties.Build ("modifier-mask");
Is_Locked_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("is-locked");
end Gtk.Accel_Group;