-----------------------------------------------------------------------
-- GtkAda - Ada95 binding for Gtk+/Gnome --
-- --
-- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet --
-- Copyright (C) 2000-2010, 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. --
-- --
-- --
-- --
-- --
-- --
-- --
-- --
-----------------------------------------------------------------------
--
-- This widget implements a drop-down menu.
-- This is basically a simple box that contains a series of Gtk_Menu_Item
-- widgets, on which the user can click to perform actions.
--
-- Such a menu is usually part of a Gtk_Menu_Bar (at the top of the window),
-- or activated by clicking on an item in another Gtk_Menu.
-- See Gtk.Option_Menu for another way of displaying menus.
--
-- All the menus in GtkAda can be "Tear off" menus, i.e you can detach
-- them from their parent (either a menu bar or another menu) to keep them
-- visible on the screen at all times).
--
-- It is worth noting that by default, the user of your application will be
-- able to dynamically modify the shortcuts associated with each menu item.
-- For instance, selecting a menu item and pressing a key will assign this
-- new shortcut to the item, possibly removing the shortcut from any other
-- item it was associated with.
--
-- Note that pressing will simply remove the shortcut.
--
-- This default behavior, somewhat unexpected, can be canceled.
-- There are two ways to control this behavior: you can lock a specific menu
-- item by calling Gtk.Widget.Lock_Accelerators on it. But you can also
-- lock all the menu items at once by calling Gtk.Accel_Group.Lock for all
-- the accelerator groups that were used (the GUI builder gate generally
-- creates a single one), as well as on the group returned by
-- Gtk.Accel_Group.Get_Default, which is the one used for items that don't
-- initially have a shortcut.
--
-- 2.16.6
-- Menus and Toolbars
-- create_menu.adb
with Gdk.Screen;
with Glib.Properties;
with Gtk.Accel_Group;
with Gtk.Menu_Item; use Gtk.Menu_Item;
with Gtk.Menu_Shell;
with Gtk.Widget;
package Gtk.Menu is
type Gtk_Menu_Record is new
Gtk.Menu_Shell.Gtk_Menu_Shell_Record with private;
type Gtk_Menu is access all Gtk_Menu_Record'Class;
type Gtk_Menu_Detach_Func is access procedure
(Attach_Widget : access Gtk.Widget.Gtk_Widget_Record'Class;
Menu : access Gtk_Menu_Record'Class);
pragma Convention (C, Gtk_Menu_Detach_Func);
-- Function called when a menu previously attached to a widget is detached.
-- An access to this function is given in Attach_To_Widget.
---------------------
-- Creating a menu --
---------------------
procedure Gtk_New (Widget : out Gtk_Menu);
-- Create a new empty menu.
procedure Initialize (Widget : access Gtk_Menu_Record'Class);
-- Internal initialization function.
-- See the section "Creating your own widgets" in the documentation.
function Get_Type return Gtk.Gtk_Type;
-- Return the internal value associated with a Gtk_Menu.
procedure Set_Active (Menu : access Gtk_Menu_Record; Index : Guint);
function Get_Active
(Menu : access Gtk_Menu_Record) return Gtk.Menu_Item.Gtk_Menu_Item;
-- Select a specified item in the menu.
-- You will almost never need this function, it is used internally by
-- Gtk_Option_Menu, for which it is the item that is currently selected.
-- Note that the item is not considered as being pressed by the user when
-- you call Set_Active, and thus no callback is called as a result.
procedure Set_Tearoff_State
(Menu : access Gtk_Menu_Record; Torn_Off : Boolean);
function Get_Tearoff_State (Menu : access Gtk_Menu_Record) return Boolean;
-- Modify the tearoff status of the menu.
-- If Torn_Off is False, the menu is displayed as a drop down menu which
-- disappears when the menu is not active. If Torn_Off is True, the menu
-- persists until it is closed or reattached.
-- Note that you can give the user access to this functionality by
-- inserting a Gtk_Tearoff_Menu_Item in the menu.
procedure Set_Title (Menu : access Gtk_Menu_Record; Title : UTF8_String);
function Get_Title (Menu : access Gtk_Menu_Record) return UTF8_String;
-- Set the title of the menu.
-- Title is displayed when the menu is displayed as a tearoff menu in an
-- independent window.
procedure Reorder_Child
(Menu : access Gtk_Menu_Record;
Child : access Gtk.Widget.Gtk_Widget_Record'Class;
Position : Gint);
-- Move an existing menu_item within the menu.
-- Its new position is given by Position, 0 being the first item in the
-- menu.
-- If Child does not exist in the menu, nothing is done.
procedure Attach
(Menu : access Gtk_Menu_Record;
Child : access Gtk.Menu_Item.Gtk_Menu_Item_Record'Class;
Left_Attach : Guint;
Right_Attach : Guint;
Top_Attach : Guint;
Bottom_Attach : Guint);
-- Adds a new #GtkMenuItem to a (table) menu. The number of 'cells' that
-- an item will occupy is specified by left_attach, right_attach,
-- top_attach and bottom_attach. These each represent the leftmost,
-- rightmost, uppermost and lower column and row numbers of the table.
-- (Columns and rows are indexed from zero).
--
-- Note that this function is not related to Detach().
--
-- Adding items to a standard menu is simply done by calling Add().
-----------------------
-- Displaying a menu --
-----------------------
type Gtk_Menu_Position_Func is access procedure
(Menu : access Gtk_Menu_Record'Class;
X : out Gint;
Y : out Gint);
-- This function is called when displaying a popup menu on the screen.
-- It should return the (X, Y) coordinates of the menu.
-- Note that you might want to attach the menu to a widget first if you
-- want to display the menu relative to its attached widget.
--
-- Note that there is a second version of this function (with added
-- user data in the package User_Menu_Popup below
procedure Popup
(Menu : access Gtk_Menu_Record;
Parent_Menu_Shell : Gtk.Menu_Shell.Gtk_Menu_Shell := null;
Parent_Menu_Item : Gtk.Menu_Item.Gtk_Menu_Item := null;
Func : Gtk_Menu_Position_Func := null;
Button : Guint := 1;
Activate_Time : Guint32 := 0);
-- Display a menu on the screen.
-- This is the function to use to create contextual menus.
-- Most of the time, the parameters can have a null value.
-- Parent_Menu_Shell is the Gtk_Menu_Shell that contains Parent_Menu_Item,
-- i.e. the widget that triggered the display of the menu.
-- Func is a function that returns the coordinates for the menu. If it is
-- null, then a default function that positions the menu at the pointer
-- location is used.
-- Button is the mouse button that was pressed to initiate the event.
-- Activate_Time is the time at which the event occurred (you can get it
-- directly from the Gdk_Event structure).
--
-- Note that a variant of this function is given in the generic package
-- User_Menu_Popup.
-- Note: in the Popup function, the Parent_* parameters are not access
-- parameters because they might be null.
type C_Gtk_Menu_Position_Func is access procedure
(Menu : System.Address;
X : out Gint;
Y : out Gint;
Push_In : out Gboolean;
User_Data : System.Address);
pragma Convention (C, C_Gtk_Menu_Position_Func);
procedure Popup
(Menu : access Gtk_Menu_Record;
Parent_Menu_Shell : Gtk.Menu_Shell.Gtk_Menu_Shell := null;
Parent_Menu_Item : Gtk.Menu_Item.Gtk_Menu_Item := null;
Func : C_Gtk_Menu_Position_Func := null;
User_Data : System.Address;
Button : Guint := 1;
Activate_Time : Guint32 := 0);
-- Similar to the Popup function above, but exposes a lower level
-- interface to a C positioning function (C_Gtk_Menu_Position_Func).
generic
--
type Data_Type is private;
--
package User_Menu_Popup is
--
type Gtk_Menu_Position_Func is access procedure
(Menu : access Gtk_Menu_Record'Class;
X : out Gint;
Y : out Gint;
User_Data : access Data_Type);
--
procedure Popup
(Menu : access Gtk_Menu_Record'Class;
Data : access Data_Type;
Parent_Menu_Shell : Gtk.Menu_Shell.Gtk_Menu_Shell := null;
Parent_Menu_Item : Gtk.Menu_Item.Gtk_Menu_Item := null;
Func : Gtk_Menu_Position_Func := null;
Button : Guint := 1;
Activate_Time : Guint32 := 0);
-- Same as the Popup function above.
-- Note that Data is not duplicated, thus you should take care of the
-- memory allocation/deallocation yourself.
-- Note also that the order of parameters is slightly different from the
-- C version.
private
procedure Internal_Menu_Position_Func_With_Data
(Menu : System.Address;
X : out Gint;
Y : out Gint;
Push_In : out Gboolean;
User_Data : System.Address);
pragma Convention (C, Internal_Menu_Position_Func_With_Data);
-- Wrapper function passed to C. This spec has been put in the
-- generic's private part because we can not use 'Access in the
-- generic body to assign to a C_Gtk_Menu_Position_Func type, because
-- the type is declared outside the generic unit. (RM 3.10.2(32))
Internal_Menu_Position_Func_With_Data_Access :
constant C_Gtk_Menu_Position_Func :=
Internal_Menu_Position_Func_With_Data'Access;
end User_Menu_Popup;
procedure Popdown (Menu : access Gtk_Menu_Record);
-- Remove the menu from the screen
procedure Reposition (Menu : access Gtk_Menu_Record);
-- Reposition a menu according to its position function.
-- This function is set when Popup is called.
procedure Set_Monitor
(Menu : access Gtk_Menu_Record;
Monitor_Num : Gint);
-- Informs GTK+ on which monitor a menu should be popped up.
-- See Gdk.Screen.Get_Monitor_Geometry.
--
-- This function should be called from a Gtk_Menu_Position_Func if the
-- menu should not appear on the same monitor as the pointer. This
-- information can't be reliably inferred from the coordinates returned
-- by a Gtk_Menu_Position_Func, since, for very long menus, these
-- coordinates may extend beyond the monitor boundaries or even the screen
-- boundaries.
function Get_Monitor (Menu : access Gtk_Menu_Record) return Gint;
-- Retrieves the number of the monitor on which to show the menu, or
-- -1 if no monitor has been set.
procedure Set_Screen
(Menu : access Gtk_Menu_Record;
Screen : access Gdk.Screen.Gdk_Screen_Record'Class);
-- Sets the Gdk_Screen on which the menu will be displayed.
--------------------------------
-- Modifying the accelerators --
--------------------------------
procedure Set_Accel_Group
(Menu : access Gtk_Menu_Record;
Accel : Accel_Group.Gtk_Accel_Group);
function Get_Accel_Group
(Menu : access Gtk_Menu_Record) return Accel_Group.Gtk_Accel_Group;
-- Set the Accel_Group that holds the global accelerators and key bindings
-- for the menu.
procedure Set_Accel_Path
(Menu : access Gtk_Menu_Record;
Accel_Path : UTF8_String);
function Get_Accel_Path (Menu : access Gtk_Menu_Record) return String;
-- Set an accelerator path for this menu from which accelerator paths
-- for its immediate children, its menu items, can be constructed.
-- The main purpose of this function is to spare the programmer the
-- inconvenience of having to call Gtk.Menu_Item.Set_Accel_Path on
-- each menu item that should support runtime user changable accelerators.
-- Instead, by just calling Gtk.Menu.Set_Accel_Path on their parent,
-- each menu item of this menu, that contains a label describing its
-- purpose, automatically gets an accel path assigned. For example, a menu
-- containing menu items "New" and "Exit", will, after
-- Set_Accel_Path (menu, "/File"); has been called, assign
-- its items the accel paths:
-- "/File/New" and "/File/Exit".
-- Assigning accel paths to menu items then enables the user to change
-- their accelerators at runtime.
----------------------------------
-- Attaching a menu to a widget --
----------------------------------
procedure Attach_To_Widget
(Menu : access Gtk_Menu_Record;
Attach_Widget : access Gtk.Widget.Gtk_Widget_Record'Class;
Detacher : Gtk_Menu_Detach_Func);
-- Attach a menu to the widget.
-- When the menu is detached from the widget (for instance when it is
-- destroyed), the procedure Detacher will be called.
-- You will almost never need to use this function, unless you specifically
-- want a call back when a widget becomes unavailable.
-- If Attach_Widget is a menu_item with a single label in it, the name of
-- the window created when Menu is teared-off will be the label in the
-- menu_item.
procedure Detach (Menu : access Gtk_Menu_Record);
-- Detach the menu from its widget, and call the Detacher set in
-- Attach_To_Widget.
function Get_Attach_Widget
(Menu : access Gtk_Menu_Record) return Gtk.Widget.Gtk_Widget;
-- Return the widget to which the menu was attached.
-- If the menu was not attached, this function returns null.
function Get_For_Attach_Widget
(Widget : access Gtk.Widget.Gtk_Widget_Record'Class)
return Gtk.Widget.Widget_List.Glist;
-- Returns a list of the menus which are attached to this widget.
-- This list is owned by GTK+ and must not be modified.
----------------
-- Properties --
----------------
-- The following properties are defined for this widget. See
-- Glib.Properties for more information on properties.
--
-- Name: Accel_Group_Property
-- Type: Object
-- Descr: The accel group holding accelerators for the menu
--
-- Name: Accel_Path_Property
-- Type: String
-- Descr: An accel path used to conveniently construct accel paths of
-- child items
--
-- Name: Active_Property
-- Type: Int
-- Descr: The currently selected menu item
--
-- Name: Attach_Widget_Property
-- Type: Object
-- Descr: The widget the menu is attached to
--
-- Name: Monitor_Property
-- Type: Int
-- Descr: The monitor the menu will be popped up on
--
-- Name: Tearoff_State_Property
-- Type: Boolean
-- Descr: A boolean that indicates whether the menu is torn-off
--
-- Name: Tearoff_Title_Property
-- Type: String
-- Descr: A title that may be displayed by the window manager when this
-- menu is torn-off
--
Accel_Group_Property : constant Glib.Properties.Property_Object;
Accel_Path_Property : constant Glib.Properties.Property_String;
Active_Property : constant Glib.Properties.Property_Int;
Attach_Widget_Property : constant Glib.Properties.Property_Object;
Monitor_Property : constant Glib.Properties.Property_Int;
Tearoff_State_Property : constant Glib.Properties.Property_Boolean;
Tearoff_Title_Property : constant Glib.Properties.Property_String;
----------------------
-- Child Properties --
----------------------
-- The following properties can be set on children of this widget. See
-- in particular Gtk.Containers.Child_Set_Property.
--
-- Name: Bottom_Attach_Property
-- Type: Int
-- Descr: The row number to attach the bottom of the child to
--
-- Name: Left_Attach_Property
-- Type: Int
-- Descr: The column number to attach the left side of the child to
--
-- Name: Right_Attach_Property
-- Type: Int
-- Descr: The column number to attach the right side of the child to
--
-- Name: Top_Attach_Property
-- Type: Int
-- Descr: The row number to attach the top of the child to
--
Bottom_Attach_Property : constant Glib.Properties.Property_Int;
Left_Attach_Property : constant Glib.Properties.Property_Int;
Right_Attach_Property : constant Glib.Properties.Property_Int;
Top_Attach_Property : constant Glib.Properties.Property_Int;
----------------------
-- Style Properties --
----------------------
-- The following properties can be changed through the gtk theme and
-- configuration files, and retrieved through Gtk.Widget.Style_Get_Property
--
-- Name: Arrow_Placement_Property
-- Type: Enum
-- Descr: Indicates where scroll arrows should be placed
--
-- Name: Arrow_Scaling_Property
-- Type: Float
-- Descr: Arbitrary constant to scale down the size of the scroll arrow
--
-- Name: Double_Arrows_Property
-- Type: Boolean
-- Descr: When scrolling, always show both arrows.
--
-- Name: Horizontal_Offset_Property
-- Type: Int
-- Descr: When the menu is a submenu, position it this number of pixels
-- offset horizontally
--
-- Name: Horizontal_Padding_Property
-- Type: Int
-- Descr: Extra space at the left and right edges of the menu
--
-- Name: Vertical_Offset_Property
-- Type: Int
-- Descr: When the menu is a submenu, position it this number of pixels
-- offset vertically
--
-- Name: Vertical_Padding_Property
-- Type: Int
-- Descr: Extra space at the top and bottom of the menu
--
Arrow_Placement_Property : constant Glib.Properties.Property_Enum;
Arrow_Scaling_Property : constant Glib.Properties.Property_Float;
Double_Arrows_Property : constant Glib.Properties.Property_Boolean;
Horizontal_Offset_Property : constant Glib.Properties.Property_Int;
Horizontal_Padding_Property : constant Glib.Properties.Property_Int;
Vertical_Offset_Property : constant Glib.Properties.Property_Int;
Vertical_Padding_Property : constant Glib.Properties.Property_Int;
-------------
-- Signals --
-------------
--
-- The following new signals are defined for this widget:
--
-- - "move_scroll"
-- procedure Handler
-- (Menu : access Gtk_Menu_Record'Class;
-- Typ : Gtk_Scroll_Type);
-- Requests that another part of the menu be made visible. Menus that
-- display lots of items might not fit on the screen. When this is the
-- case, gtk+ will insert some scrolling arrows on both ends of the menus
-- and emitting this signal will behave as if the user had clicked on one
-- of these arrows.
-- This signal is mostly useful as a keybinding
--
--
Signal_Move_Scroll : constant Glib.Signal_Name := "move_scroll";
private
type Gtk_Menu_Record is new Gtk.Menu_Shell.Gtk_Menu_Shell_Record
with null record;
Accel_Group_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("accel-group");
Accel_Path_Property : constant Glib.Properties.Property_String :=
Glib.Properties.Build ("accel-path");
Active_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("active");
Attach_Widget_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("attach-widget");
Monitor_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("monitor");
Tearoff_State_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("tearoff-state");
Tearoff_Title_Property : constant Glib.Properties.Property_String :=
Glib.Properties.Build ("tearoff-title");
Bottom_Attach_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("bottom-attach");
Left_Attach_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("left-attach");
Right_Attach_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("right-attach");
Top_Attach_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("top-attach");
Arrow_Placement_Property : constant Glib.Properties.Property_Enum :=
Glib.Properties.Build ("arrow-placement");
Arrow_Scaling_Property : constant Glib.Properties.Property_Float :=
Glib.Properties.Build ("arrow-scaling");
Double_Arrows_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("double-arrows");
Horizontal_Offset_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("horizontal-offset");
Horizontal_Padding_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("horizontal-padding");
Vertical_Offset_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("vertical-offset");
Vertical_Padding_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("vertical-padding");
pragma Import (C, Get_Type, "gtk_menu_get_type");
end Gtk.Menu;
--
-- ../examples/documentation/contextual.adb
--