----------------------------------------------------------------------- -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2013, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or -- -- modify it under the terms of the GNU General Public -- -- License as published by the Free Software Foundation; either -- -- version 2 of the License, 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 -- -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -- -- General Public License for more details. -- -- -- -- You should have received a copy of the GNU General Public -- -- License along with this library; if not, write to the -- -- Free Software Foundation, Inc., 59 Temple Place - Suite 330, -- -- Boston, MA 02111-1307, USA. -- -- -- -- As a special exception, if other files instantiate generics from -- -- this unit, or you link this unit with other files to produce an -- -- executable, this unit does not by itself cause the resulting -- -- executable to be covered by the GNU General Public License. This -- -- exception does not however invalidate any other reasons why the -- -- executable file might be covered by the GNU Public License. -- ----------------------------------------------------------------------- -- <description> -- An accel group represents a group of keyboard accelerators, generally -- attached to a toplevel window. Accelerators are different from mnemonics. -- Accelerators are shortcuts for activating a menu item. They appear -- alongside the menu item they are a shortcut for. Mnemonics are shortcuts -- for GUI elements, such as buttons. They appear as underline characters. -- Menu items can have both. -- -- </description> pragma Warnings (Off, "*is already use-visible*");
with Gdk; use Gdk;
with Gdk.Types; use Gdk.Types;
with Glib; use Glib;
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 new Guint;
Accel_Visible : constant Gtk_Accel_Flags := 2 ** 0;
Accel_Locked : constant Gtk_Accel_Flags := 2 ** 1;
Accel_Mask : constant Gtk_Accel_Flags := 16#07#;
type Gtk_Accel_Key is record
Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Flags : Gtk_Accel_Flags; end record;
pragma Convention (C, Gtk_Accel_Key);
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. type C_Gtk_Accel_Group_Find_Func is access function
(Key : access Gtk_Accel_Key;
Closure : C_Gtk_Accel_Group_Activate; Data : System.Address) return Boolean; pragma Convention (C, C_Gtk_Accel_Group_Find_Func);
-- When a match is found, must return True. -- Must not modify Key ------------------ -- Constructors -- ------------------ procedure Gtk_New (Accel_Group : out Gtk_Accel_Group);
procedure Initialize (Accel_Group : 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 Get_Type return Glib.GType;
pragma Import (C, Get_Type, "gtk_accel_group_get_type");
------------- -- Methods -- ------------- function Activate
(Accel_Group : access Gtk_Accel_Group_Record;
Accel_Quark : GQuark;
Acceleratable : 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 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 : 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 GtkAccelGroupActivate. 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 : 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 for the path. The signature used for the Closure is that -- of GtkAccelGroupActivate. Note that Accel_Path string will be stored in -- a 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 : 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 : 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 : access Gtk_Accel_Group_Record;
Find_Func : C_Gtk_Accel_Group_Find_Func;
Data : System.Address) return Gtk_Accel_Key;
-- Finds the first entry in an accelerator group for which -- "find_func": a function to filter the entries of Accel_Group with -- "data": data to pass to Find_Func function Get_Is_Locked
(Accel_Group : access Gtk_Accel_Group_Record) return Boolean;
-- Locks are added and removed using Gtk.Accel_Group.Lock and -- Gtk.Accel_Group.Unlock. False otherwise. -- Since: gtk+ 2.14 function Get_Modifier_Mask
(Accel_Group : access Gtk_Accel_Group_Record)
return Gdk.Types.Gdk_Modifier_Type;
-- Gets a Gdk.Types.Gdk_Modifier_Type representing the mask for this -- Since: gtk+ 2.14 procedure Lock (Accel_Group : 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 : 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.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 : 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 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 : 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 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_a keyval plus -- GDK_CONTROL_MASK is valid - this is a "Ctrl+a" accelerator. But, you -- can't, for instance, use the GDK_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 -- "accelerator_mods": return location for accelerator modifier mask 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_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);
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) -- -- Name: Is_Locked_Property -- Type: Boolean -- Flags: read-write -- -- Name: Modifier_Mask_Property -- Type: Gdk.ModifierType -- Flags: read-write Is_Locked_Property : constant Glib.Properties.Property_Boolean;
Modifier_Mask_Property : constant Glib.Properties.Property_Boxed;
------------- -- Signals -- ------------- -- The following new signals are defined for this widget: -- -- "accel-activate" -- function Handler -- (Self : access Gtk_Accel_Group_Record'Class; -- Acceleratable : Glib.Object.GObject; -- Keyval : Guint; -- Modifier : Gdk.ModifierType) return Boolean; -- -- "acceleratable": the object on which the accelerator was activated -- -- "keyval": the accelerator keyval -- -- "modifier": the modifier combination of the accelerator -- The accel-activate signal is an implementation detail of -- Gtk.Accel_Group.Gtk_Accel_Group and not meant to be used by -- applications. -- Returns True if the accelerator was activated -- -- "accel-changed" -- procedure Handler -- (Self : access Gtk_Accel_Group_Record'Class; -- Keyval : Guint; -- Modifier : Gdk.ModifierType; -- Accel_Closure : System.Address); -- -- "keyval": the accelerator keyval -- -- "modifier": the modifier combination of the accelerator -- -- "accel_closure": the GClosure of the accelerator -- The accel-changed signal is emitted when a GtkAccelGroupEntry is added -- to or removed from the accel group. Widgets like -- Gtk.Accellabel.Gtk_Accellabel which display an associated accelerator -- should connect to this signal, and rebuild their visual representation -- if the Accel_Closure is theirs. Signal_Accel_Activate : constant Glib.Signal_Name := "accel-activate";
Signal_Accel_Changed : constant Glib.Signal_Name := "accel-changed";
private Is_Locked_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("is-locked");
Modifier_Mask_Property : constant Glib.Properties.Property_Boxed :=
Glib.Properties.Build ("modifier-mask");
end Gtk.Accel_Group;