------------------------------------------------------------------------------ -- -- -- 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.Menu.Gtk_Menu is a Gtk.Menu_Shell.Gtk_Menu_Shell that implements a -- drop down menu consisting of a list of Gtk.Menu_Item.Gtk_Menu_Item objects -- which can be navigated and activated by the user to perform application -- functions. -- -- A Gtk.Menu.Gtk_Menu is most commonly dropped down by activating a -- Gtk.Menu_Item.Gtk_Menu_Item in a Gtk.Menu_Bar.Gtk_Menu_Bar or popped up by -- activating a Gtk.Menu_Item.Gtk_Menu_Item in another Gtk.Menu.Gtk_Menu. -- -- A Gtk.Menu.Gtk_Menu can also be popped up by activating a -- Gtk.Combo_Box.Gtk_Combo_Box. Other composite widgets such as the -- Gtk.Notebook.Gtk_Notebook can pop up a Gtk.Menu.Gtk_Menu as well. -- -- Applications can display a Gtk.Menu.Gtk_Menu as a popup menu by calling -- the Gtk.Menu.Popup function. The example below shows how an application can -- pop up a menu when the 3rd mouse button is pressed. -- -- == Connecting the popup signal handler. == -- -- /<!---->* connect our handler which will popup the menu *<!---->/ -- g_signal_connect_swapped (window, "button_press_event", -- G_CALLBACK (my_popup_handler), menu); -- -- == Signal handler which displays a popup menu. == -- -- static gint -- my_popup_handler (GtkWidget *widget, GdkEvent *event) -- { -- GtkMenu *menu; -- GdkEventButton *event_button; -- g_return_val_if_fail (widget != NULL, FALSE); -- g_return_val_if_fail (GTK_IS_MENU (widget), FALSE); -- g_return_val_if_fail (event != NULL, FALSE); -- /<!---->* The "widget" is the menu that was supplied when -- * g_signal_connect_swapped was called. -- *<!---->/ -- menu = GTK_MENU (widget); -- if (event->type == GDK_BUTTON_PRESS) -- { -- event_button = (GdkEventButton *) event; -- if (event_button->button == GDK_BUTTON_SECONDARY) -- { -- gtk_menu_popup (menu, NULL, NULL, NULL, NULL, -- event_button->button, event_button->time); -- return TRUE; -- } -- } -- return FALSE; -- } -- -- -- </description> pragma Ada_2005; pragma Warnings (Off, "*is already use-visible*");
with Gdk.Device; use Gdk.Device;
with Gdk.Screen; use Gdk.Screen;
with Glib; use Glib;
with Glib.Menu_Model; use Glib.Menu_Model;
with Glib.Object; use Glib.Object;
with Glib.Properties; use Glib.Properties;
with Glib.Types; use Glib.Types;
with Gtk.Accel_Group; use Gtk.Accel_Group;
with Gtk.Buildable; use Gtk.Buildable;
with Gtk.Enums; use Gtk.Enums;
with Gtk.Menu_Item; use Gtk.Menu_Item;
with Gtk.Menu_Shell; use Gtk.Menu_Shell;
with Gtk.Widget; use Gtk.Widget;
package Gtk.Menu is
type Gtk_Menu_Record is new Gtk_Menu_Shell_Record with null record;
type Gtk_Menu is access all Gtk_Menu_Record'Class;
--------------- -- Callbacks -- --------------- type Gtk_Menu_Detach_Func is access procedure (Attach_Widget : System.Address; Menu : System.Address);
-- A user function supplied when calling Gtk.Menu.Attach_To_Widget which -- will be called when the menu is later detached from the widget. -- "attach_widget": the Gtk.Widget.Gtk_Widget that the menu is being -- detached from. -- "menu": the Gtk.Menu.Gtk_Menu being detached. pragma Convention (C, Gtk_Menu_Detach_Func);
type Gtk_Menu_Position_Func is access procedure
(Menu : not null access Gtk_Menu_Record'Class;
X : in out Gint;
Y : in out Gint;
Push_In : out Boolean); -- A user function supplied when calling Gtk.Menu.Popup which controls the -- positioning of the menu when it is displayed. The function sets the X -- and Y parameters to the coordinates where the menu is to be drawn. To -- make the menu appear on a different monitor than the mouse pointer, -- gtk_menu_set_monitor must be called. -- "menu": a Gtk.Menu.Gtk_Menu. -- "x": address of the Gint representing the horizontal position where the -- menu shall be drawn. -- "y": address of the Gint representing the vertical position where the -- menu shall be drawn. This is an output parameter. -- "push_in": This parameter controls how menus placed outside the monitor -- are handled. If this is set to True and part of the menu is outside the -- monitor then GTK+ pushes the window into the visible area, effectively -- modifying the popup position. Note that moving and possibly resizing the -- menu around will alter the scroll position to keep the menu items "in -- place", i.e. at the same monitor position they would have been without -- resizing. In practice, this behavior is only useful for combobox popups -- or option menus and cannot be used to simply confine a menu to monitor -- boundaries. In that case, changing the scroll offset is not desirable. ------------------ -- Constructors -- ------------------ procedure Gtk_New (Menu : out Gtk_Menu);
procedure Initialize (Menu : not null access Gtk_Menu_Record'Class);
-- Creates a new Gtk.Menu.Gtk_Menu function Gtk_Menu_New return Gtk_Menu;
-- Creates a new Gtk.Menu.Gtk_Menu procedure Gtk_New_From_Model
(Menu : out Gtk_Menu;
Model : not null access Glib.Menu_Model.Gmenu_Model_Record'Class);
procedure Initialize_From_Model
(Menu : not null access Gtk_Menu_Record'Class;
Model : not null access Glib.Menu_Model.Gmenu_Model_Record'Class);
-- Creates a Gtk.Menu.Gtk_Menu and populates it with menu items and -- submenus according to Model. -- The created menu items are connected to actions found in the -- Gtk.Application_Window.Gtk_Application_Window to which the menu belongs -- - typically by means of being attached to a widget (see -- Gtk.Menu.Attach_To_Widget) that is contained within the -- Gtk_Application_Windows widget hierarchy. -- Since: gtk+ 3.4 -- "model": a Glib.Menu_Model.Gmenu_Model function Gtk_Menu_New_From_Model
(Model : not null access Glib.Menu_Model.Gmenu_Model_Record'Class)
return Gtk_Menu;
-- Creates a Gtk.Menu.Gtk_Menu and populates it with menu items and -- submenus according to Model. -- The created menu items are connected to actions found in the -- Gtk.Application_Window.Gtk_Application_Window to which the menu belongs -- - typically by means of being attached to a widget (see -- Gtk.Menu.Attach_To_Widget) that is contained within the -- Gtk_Application_Windows widget hierarchy. -- Since: gtk+ 3.4 -- "model": a Glib.Menu_Model.Gmenu_Model function Get_Type return Glib.GType;
pragma Import (C, Get_Type, "gtk_menu_get_type");
------------- -- Methods -- ------------- procedure Attach
(Menu : not null access Gtk_Menu_Record;
Child : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Left_Attach : Guint;
Right_Attach : Guint;
Top_Attach : Guint;
Bottom_Attach : Guint);
-- Adds a new Gtk.Menu_Item.Gtk_Menu_Item 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 Gtk.Menu.Detach. -- Since: gtk+ 2.4 -- "child": a Gtk.Menu_Item.Gtk_Menu_Item -- "left_attach": The column number to attach the left side of the item to -- "right_attach": The column number to attach the right side of the item -- to -- "top_attach": The row number to attach the top of the item to -- "bottom_attach": The row number to attach the bottom of the item to procedure Attach_To_Widget
(Menu : not null access Gtk_Menu_Record;
Attach_Widget : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Detacher : Gtk_Menu_Detach_Func);
-- Attaches the menu to the widget and provides a callback function that -- will be invoked when the menu calls Gtk.Menu.Detach during its -- destruction. -- "attach_widget": the Gtk.Widget.Gtk_Widget that the menu will be -- attached to -- "detacher": the user supplied callback function that will be called -- when the menu calls Gtk.Menu.Detach procedure Detach (Menu : not null access Gtk_Menu_Record);
-- Detaches the menu from the widget to which it had been attached. This -- function will call the callback function, Detacher, provided when the -- Gtk.Menu.Attach_To_Widget function was called. function Get_Accel_Group
(Menu : not null access Gtk_Menu_Record)
return Gtk.Accel_Group.Gtk_Accel_Group;
-- Gets the Gtk.Accel_Group.Gtk_Accel_Group which holds global -- accelerators for the menu. See Gtk.Menu.Set_Accel_Group. procedure Set_Accel_Group
(Menu : not null access Gtk_Menu_Record;
Accel_Group : access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class);
-- Set the Gtk.Accel_Group.Gtk_Accel_Group which holds global accelerators -- for the menu. This accelerator group needs to also be added to all -- windows that this menu is being used in with Gtk.Window.Add_Accel_Group, -- in order for those windows to support all the accelerators contained in -- this group. -- "accel_group": the Gtk.Accel_Group.Gtk_Accel_Group to be associated -- with the menu. function Get_Accel_Path
(Menu : not null access Gtk_Menu_Record) return UTF8_String;
-- Retrieves the accelerator path set on the menu. -- Since: gtk+ 2.14 procedure Set_Accel_Path
(Menu : not null access Gtk_Menu_Record;
Accel_Path : UTF8_String := "");
-- Sets 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 -- 'gtk_menu_set_accel_path (menu, "<Gnumeric-Sheet>/File");' has been -- called, assign its items the accel paths: '"<Gnumeric-Sheet>/File/New"' -- and '"<Gnumeric-Sheet>/File/Exit"'. -- Assigning accel paths to menu items then enables the user to change -- their accelerators at runtime. More details about accelerator paths and -- their default setups can be found at Gtk.Accel_Map.Add_Entry. -- 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": a valid accelerator path function Get_Active
(Menu : not null access Gtk_Menu_Record)
return Gtk.Menu_Item.Gtk_Menu_Item;
-- Returns the selected menu item from the menu. This is used by the -- Gtk.Combo_Box.Gtk_Combo_Box. procedure Set_Active
(Menu : not null access Gtk_Menu_Record;
Index : Guint);
-- Selects the specified menu item within the menu. This is used by the -- Gtk.Combo_Box.Gtk_Combo_Box and should not be used by anyone else. -- "index": the index of the menu item to select. Iindex values are from 0 -- to n-1 function Get_Attach_Widget
(Menu : not null access Gtk_Menu_Record) return Gtk.Widget.Gtk_Widget;
-- Returns the Gtk.Widget.Gtk_Widget that the menu is attached to. function Get_Monitor (Menu : not null access Gtk_Menu_Record) return Gint;
-- Retrieves the number of the monitor on which to show the menu. -- Since: gtk+ 2.14 procedure Set_Monitor
(Menu : not null 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. -- Since: gtk+ 2.4 -- "monitor_num": the number of the monitor on which the menu should be -- popped up function Get_Reserve_Toggle_Size
(Menu : not null access Gtk_Menu_Record) return Boolean;
-- Returns whether the menu reserves space for toggles and icons, -- regardless of their actual presence. -- Since: gtk+ 2.18 procedure Set_Reserve_Toggle_Size
(Menu : not null access Gtk_Menu_Record;
Reserve_Toggle_Size : Boolean);
-- Sets whether the menu should reserve space for drawing toggles or -- icons, regardless of their actual presence. -- Since: gtk+ 2.18 -- "reserve_toggle_size": whether to reserve size for toggles function Get_Tearoff_State
(Menu : not null access Gtk_Menu_Record) return Boolean;
-- Returns whether the menu is torn off. See Gtk.Menu.Set_Tearoff_State. procedure Set_Tearoff_State
(Menu : not null access Gtk_Menu_Record;
Torn_Off : Boolean);
-- Changes the tearoff state of the menu. A menu is normally displayed as -- drop down menu which persists as long as the menu is active. It can also -- be displayed as a tearoff menu which persists until it is closed or -- reattached. -- "torn_off": If True, menu is displayed as a tearoff menu. function Get_Title
(Menu : not null access Gtk_Menu_Record) return UTF8_String;
-- Returns the title of the menu. See Gtk.Menu.Set_Title. procedure Set_Title
(Menu : not null access Gtk_Menu_Record;
Title : UTF8_String);
-- Sets the title string for the menu. -- The title is displayed when the menu is shown as a tearoff menu. If -- Title is null, the menu will see if it is attached to a parent menu -- item, and if so it will try to use the same text as that menu item's -- label. -- "title": a string containing the title for the menu procedure Popdown (Menu : not null access Gtk_Menu_Record);
-- Removes the menu from the screen. procedure Popup
(Menu : not null 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);
-- Displays a menu and makes it available for selection. -- Applications can use this function to display context-sensitive menus, -- and will typically supply null for the Parent_Menu_Shell, -- Parent_Menu_Item, Func and Data parameters. The default menu positioning -- function will position the menu at the current mouse cursor position. -- The Button parameter should be the mouse button pressed to initiate the -- menu popup. If the menu popup was initiated by something other than a -- mouse button press, such as a mouse button release or a keypress, Button -- should be 0. -- The Activate_Time parameter is used to conflict-resolve initiation of -- concurrent requests for mouse/keyboard grab requests. To function -- properly, this needs to be the timestamp of the user event (such as a -- mouse click or key press) that caused the initiation of the popup. Only -- if no such event is available, Gtk.Main.Get_Current_Event_Time can be -- used instead. -- "parent_menu_shell": the menu shell containing the triggering menu -- item, or null -- "parent_menu_item": the menu item whose activation triggered the popup, -- or null -- "func": a user supplied function used to position the menu, or null -- "button": the mouse button which was pressed to initiate the event. -- "activate_time": the time at which the activation event occurred. generic type User_Data_Type (<>) is private;
with procedure Destroy (Data : in out User_Data_Type) is null;
package Popup_User_Data is
type Gtk_Menu_Position_Func is access procedure
(Menu : not null access Gtk.Menu.Gtk_Menu_Record'Class;
X : in out Gint;
Y : in out Gint;
Push_In : out Boolean; User_Data : User_Data_Type); -- A user function supplied when calling Gtk.Menu.Popup which controls the -- positioning of the menu when it is displayed. The function sets the X -- and Y parameters to the coordinates where the menu is to be drawn. To -- make the menu appear on a different monitor than the mouse pointer, -- gtk_menu_set_monitor must be called. -- "menu": a Gtk.Menu.Gtk_Menu. -- "x": address of the Gint representing the horizontal position where the -- menu shall be drawn. -- "y": address of the Gint representing the vertical position where the -- menu shall be drawn. This is an output parameter. -- "push_in": This parameter controls how menus placed outside the monitor -- are handled. If this is set to True and part of the menu is outside the -- monitor then GTK+ pushes the window into the visible area, effectively -- modifying the popup position. Note that moving and possibly resizing the -- menu around will alter the scroll position to keep the menu items "in -- place", i.e. at the same monitor position they would have been without -- resizing. In practice, this behavior is only useful for combobox popups -- or option menus and cannot be used to simply confine a menu to monitor -- boundaries. In that case, changing the scroll offset is not desirable. -- "user_data": the data supplied by the user in the Gtk.Menu.Popup Data -- parameter. procedure Popup
(Menu : not null access Gtk.Menu.Gtk_Menu_Record'Class;
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;
Data : User_Data_Type;
Button : Guint := 1;
Activate_Time : Guint32 := 0);
-- Displays a menu and makes it available for selection. -- Applications can use this function to display context-sensitive -- menus, and will typically supply null for the Parent_Menu_Shell, -- Parent_Menu_Item, Func and Data parameters. The default menu -- positioning function will position the menu at the current mouse -- cursor position. -- The Button parameter should be the mouse button pressed to initiate -- the menu popup. If the menu popup was initiated by something other -- than a mouse button press, such as a mouse button release or a -- keypress, Button should be 0. -- The Activate_Time parameter is used to conflict-resolve initiation -- of concurrent requests for mouse/keyboard grab requests. To function -- properly, this needs to be the timestamp of the user event (such as a -- mouse click or key press) that caused the initiation of the popup. -- Only if no such event is available, Gtk.Main.Get_Current_Event_Time -- can be used instead. -- "parent_menu_shell": the menu shell containing the triggering menu -- item, or null -- "parent_menu_item": the menu item whose activation triggered the -- popup, or null -- "func": a user supplied function used to position the menu, or null -- "data": user supplied data to be passed to Func. -- "button": the mouse button which was pressed to initiate the event. -- "activate_time": the time at which the activation event occurred. end Popup_User_Data;
procedure Popup_For_Device
(Menu : not null access Gtk_Menu_Record;
Device : access Gdk.Device.Gdk_Device_Record'Class;
Parent_Menu_Shell : access Gtk.Widget.Gtk_Widget_Record'Class;
Parent_Menu_Item : access Gtk.Widget.Gtk_Widget_Record'Class;
Func : Gtk_Menu_Position_Func;
Button : Guint;
Activate_Time : Guint32);
-- Displays a menu and makes it available for selection. -- Applications can use this function to display context-sensitive menus, -- and will typically supply null for the Parent_Menu_Shell, -- Parent_Menu_Item, Func, Data and Destroy parameters. The default menu -- positioning function will position the menu at the current position of -- Device (or its corresponding pointer). -- The Button parameter should be the mouse button pressed to initiate the -- menu popup. If the menu popup was initiated by something other than a -- mouse button press, such as a mouse button release or a keypress, Button -- should be 0. -- The Activate_Time parameter is used to conflict-resolve initiation of -- concurrent requests for mouse/keyboard grab requests. To function -- properly, this needs to be the time stamp of the user event (such as a -- mouse click or key press) that caused the initiation of the popup. Only -- if no such event is available, Gtk.Main.Get_Current_Event_Time can be -- used instead. -- Since: gtk+ 3.0 -- "device": a Gdk.Device.Gdk_Device -- "parent_menu_shell": the menu shell containing the triggering menu -- item, or null -- "parent_menu_item": the menu item whose activation triggered the popup, -- or null -- "func": a user supplied function used to position the menu, or null -- "button": the mouse button which was pressed to initiate the event -- "activate_time": the time at which the activation event occurred generic type User_Data_Type (<>) is private;
with procedure Destroy (Data : in out User_Data_Type) is null;
package Popup_For_Device_User_Data is
type Gtk_Menu_Position_Func is access procedure
(Menu : not null access Gtk.Menu.Gtk_Menu_Record'Class;
X : out Gint;
Y : out Gint;
Push_In : out Boolean; User_Data : User_Data_Type); -- A user function supplied when calling Gtk.Menu.Popup which controls the -- positioning of the menu when it is displayed. The function sets the X -- and Y parameters to the coordinates where the menu is to be drawn. To -- make the menu appear on a different monitor than the mouse pointer, -- gtk_menu_set_monitor must be called. -- "menu": a Gtk.Menu.Gtk_Menu. -- "x": address of the Gint representing the horizontal position where the -- menu shall be drawn. -- "y": address of the Gint representing the vertical position where the -- menu shall be drawn. This is an output parameter. -- "push_in": This parameter controls how menus placed outside the monitor -- are handled. If this is set to True and part of the menu is outside the -- monitor then GTK+ pushes the window into the visible area, effectively -- modifying the popup position. Note that moving and possibly resizing the -- menu around will alter the scroll position to keep the menu items "in -- place", i.e. at the same monitor position they would have been without -- resizing. In practice, this behavior is only useful for combobox popups -- or option menus and cannot be used to simply confine a menu to monitor -- boundaries. In that case, changing the scroll offset is not desirable. -- "user_data": the data supplied by the user in the Gtk.Menu.Popup Data -- parameter. procedure Popup_For_Device
(Menu : not null access Gtk.Menu.Gtk_Menu_Record'Class;
Device : access Gdk.Device.Gdk_Device_Record'Class;
Parent_Menu_Shell : access Gtk.Widget.Gtk_Widget_Record'Class;
Parent_Menu_Item : access Gtk.Widget.Gtk_Widget_Record'Class;
Func : Gtk_Menu_Position_Func;
Data : User_Data_Type;
Button : Guint;
Activate_Time : Guint32);
-- Displays a menu and makes it available for selection. -- Applications can use this function to display context-sensitive -- menus, and will typically supply null for the Parent_Menu_Shell, -- Parent_Menu_Item, Func, Data and Destroy parameters. The default menu -- positioning function will position the menu at the current position -- of Device (or its corresponding pointer). -- The Button parameter should be the mouse button pressed to initiate -- the menu popup. If the menu popup was initiated by something other -- than a mouse button press, such as a mouse button release or a -- keypress, Button should be 0. -- The Activate_Time parameter is used to conflict-resolve initiation -- of concurrent requests for mouse/keyboard grab requests. To function -- properly, this needs to be the time stamp of the user event (such as -- a mouse click or key press) that caused the initiation of the popup. -- Only if no such event is available, Gtk.Main.Get_Current_Event_Time -- can be used instead. -- Since: gtk+ 3.0 -- "device": a Gdk.Device.Gdk_Device -- "parent_menu_shell": the menu shell containing the triggering menu -- item, or null -- "parent_menu_item": the menu item whose activation triggered the -- popup, or null -- "func": a user supplied function used to position the menu, or null -- "data": user supplied data to be passed to Func -- "button": the mouse button which was pressed to initiate the event -- "activate_time": the time at which the activation event occurred end Popup_For_Device_User_Data;
procedure Reorder_Child
(Menu : not null access Gtk_Menu_Record;
Child : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Position : Gint);
-- Moves Child to a new Position in the list of Menu children. -- "child": the Gtk.Menu_Item.Gtk_Menu_Item to move -- "position": the new position to place Child. Positions are numbered -- from 0 to n - 1 procedure Reposition (Menu : not null access Gtk_Menu_Record);
-- Repositions the menu according to its position function. procedure Set_Screen
(Menu : not null access Gtk_Menu_Record;
Screen : access Gdk.Screen.Gdk_Screen_Record'Class);
-- Sets the Gdk.Screen.Gdk_Screen on which the menu will be displayed. -- Since: gtk+ 2.2 -- "screen": a Gdk.Screen.Gdk_Screen, or null if the screen should be -- determined by the widget the menu is attached to --------------- -- Functions -- --------------- function Get_For_Attach_Widget
(Widget : not null 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. -- Since: gtk+ 2.6 -- "widget": a Gtk.Widget.Gtk_Widget ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Accel_Group_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Accel_Group.Gtk_Accel_Group -- The accel group holding accelerators for the menu. Accel_Path_Property : constant Glib.Properties.Property_String;
-- An accel path used to conveniently construct accel paths of child -- items. Active_Property : constant Glib.Properties.Property_Int;
-- The index of the currently selected menu item, or -1 if no menu item is -- selected. Attach_Widget_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Widget.Gtk_Widget -- The widget the menu is attached to. Setting this property attaches the -- menu without a Gtk_Menu_Detach_Func. If you need to use a detacher, use -- Gtk.Menu.Attach_To_Widget directly. Monitor_Property : constant Glib.Properties.Property_Int;
-- The monitor the menu will be popped up on. Reserve_Toggle_Size_Property : constant Glib.Properties.Property_Boolean;
-- A boolean that indicates whether the menu reserves space for toggles -- and icons, regardless of their actual presence. -- -- This property should only be changed from its default value for -- special-purposes such as tabular menus. Regular menus that are connected -- to a menu bar or context menus should reserve toggle space for -- consistency. Tearoff_State_Property : constant Glib.Properties.Property_Boolean;
-- A boolean that indicates whether the menu is torn-off. Tearoff_Title_Property : constant Glib.Properties.Property_String;
------------- -- Signals -- ------------- type Cb_Gtk_Menu_Gtk_Scroll_Type_Void is not null access procedure
(Self : access Gtk_Menu_Record'Class;
Scroll_Type : Gtk.Enums.Gtk_Scroll_Type); type Cb_GObject_Gtk_Scroll_Type_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Scroll_Type : Gtk.Enums.Gtk_Scroll_Type); Signal_Move_Scroll : constant Glib.Signal_Name := "move-scroll";
procedure On_Move_Scroll
(Self : not null access Gtk_Menu_Record;
Call : Cb_Gtk_Menu_Gtk_Scroll_Type_Void;
After : Boolean := False);
procedure On_Move_Scroll
(Self : not null access Gtk_Menu_Record;
Call : Cb_GObject_Gtk_Scroll_Type_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements
(Gtk.Buildable.Gtk_Buildable, Gtk_Menu_Record, Gtk_Menu);
function "+"
(Widget : access Gtk_Menu_Record'Class)
return Gtk.Buildable.Gtk_Buildable
renames Implements_Gtk_Buildable.To_Interface;
function "-"
(Interf : Gtk.Buildable.Gtk_Buildable)
return Gtk_Menu
renames Implements_Gtk_Buildable.To_Object;
private Tearoff_Title_Property : constant Glib.Properties.Property_String :=
Glib.Properties.Build ("tearoff-title");
Tearoff_State_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("tearoff-state");
Reserve_Toggle_Size_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("reserve-toggle-size");
Monitor_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("monitor");
Attach_Widget_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("attach-widget");
Active_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("active");
Accel_Path_Property : constant Glib.Properties.Property_String :=
Glib.Properties.Build ("accel-path");
Accel_Group_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("accel-group");
end Gtk.Menu;