File: gtk-ui_manager.ads

------------------------------------------------------------------------------

--                                                                          --

--      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.UI_Manager.Gtk_UI_Manager constructs a user interface (menus and

--  toolbars) from one or more UI definitions, which reference actions from one

```
--  or more action groups. 
```
```
-- 
```
```
--  == UI Definitions == 
```
```
-- 
```

--  The UI definitions are specified in an XML format which can be roughly

```
--  described by the following DTD. 
```
```
-- 
```
```
--  Note: 
```
```
-- 
```

--  Do not confuse the GtkUIManager UI Definitions described here with the

--  similarly named <link linkend="BUILDER-UI">GtkBuilder UI

```
--  Definitions</link>. 
```
```
-- 
```

--    <!ELEMENT ui          (menubar|toolbar|popup|accelerator)* >

--    <!ELEMENT menubar     (menuitem|separator|placeholder|menu)* >

--    <!ELEMENT menu        (menuitem|separator|placeholder|menu)* >

--    <!ELEMENT popup       (menuitem|separator|placeholder|menu)* >

--    <!ELEMENT toolbar     (toolitem|separator|placeholder)* >

--    <!ELEMENT placeholder (menuitem|toolitem|separator|placeholder|menu)* >

```
--    <!ELEMENT menuitem     EMPTY > 
```
```
--    <!ELEMENT toolitem     (menu?) > 
```
```
--    <!ELEMENT separator    EMPTY > 
```
```
--    <!ELEMENT accelerator  EMPTY > 
```

--    <!ATTLIST menubar      name                      IMPLIED

--    action                    IMPLIED >

--    <!ATTLIST toolbar      name                      IMPLIED

--    action                    IMPLIED >

--    <!ATTLIST popup        name                      IMPLIED

--    action                    IMPLIED

--    accelerators (true|false) IMPLIED >

--    <!ATTLIST placeholder  name                      IMPLIED

--    action                    IMPLIED >

--    <!ATTLIST separator    name                      IMPLIED

--    action                    IMPLIED

--    expand       (true|false) IMPLIED >

--    <!ATTLIST menu         name                      IMPLIED

--    action                    REQUIRED

--    position     (top|bot)    IMPLIED >

--    <!ATTLIST menuitem     name                      IMPLIED

--    action                    REQUIRED

--    position     (top|bot)    IMPLIED

--    always-show-image (true|false) IMPLIED >

--    <!ATTLIST toolitem     name                      IMPLIED

--    action                    REQUIRED

--    position     (top|bot)    IMPLIED >

--    <!ATTLIST accelerator  name                      IMPLIED

--    action                    REQUIRED >

--  There are some additional restrictions beyond those specified in the DTD,

--  e.g. every toolitem must have a toolbar in its anchestry and every menuitem

--  must have a menubar or popup in its anchestry. Since a GMarkup parser is

--  used to parse the UI description, it must not only be valid XML, but valid

```
--  GMarkup. 
```
```
-- 
```

--  If a name is not specified, it defaults to the action. If an action is not

--  specified either, the element name is used. The name and action attributes

--  must not contain '/' characters after parsing (since that would mess up

--  path lookup) and must be usable as XML attributes when enclosed in

--  doublequotes, thus they must not '"' characters or references to the &quot;

```
--  entity. 
```
```
-- 
```
```
--  == A UI definition == 
```
```
-- 
```
```
--    <ui> 
```
```
--    <menubar> 
```

--    <menu name="FileMenu" action="FileMenuAction">

--    <menuitem name="New" action="New2Action" />

--    <placeholder name="FileMenuAdditions" />

```
--    </menu> 
```

--    <menu name="JustifyMenu" action="JustifyMenuAction">

--    <menuitem name="Left" action="justify-left"/>

--    <menuitem name="Centre" action="justify-center"/>

--    <menuitem name="Right" action="justify-right"/>

--    <menuitem name="Fill" action="justify-fill"/>

```
--    </menu> 
```
```
--    </menubar> 
```
```
--    <toolbar action="toolbar1"> 
```

--    <placeholder name="JustifyToolItems">

```
--    <separator/> 
```

--    <toolitem name="Left" action="justify-left"/>

--    <toolitem name="Centre" action="justify-center"/>

--    <toolitem name="Right" action="justify-right"/>

--    <toolitem name="Fill" action="justify-fill"/>

```
--    <separator/> 
```
```
--    </placeholder> 
```
```
--    </toolbar> 
```
```
--    </ui> 
```

--  The constructed widget hierarchy is very similar to the element tree of

--  the XML, with the exception that placeholders are merged into their

--  parents. The correspondence of XML elements to widgets should be almost

```
--  obvious: 
```
```
-- 
```
```
--  'menubar' 
```
```
-- 
```
```
--     * a Gtk.Menu_Bar.Gtk_Menu_Bar 
```
```
-- 
```
```
--  'toolbar' 
```
```
-- 
```
```
--     * a Gtk.Toolbar.Gtk_Toolbar 
```
```
-- 
```
```
--  'popup' 
```
```
-- 
```
```
--     * a toplevel Gtk.Menu.Gtk_Menu 
```
```
-- 
```
```
--  'menu' 
```
```
-- 
```

--     * a Gtk.Menu.Gtk_Menu attached to a menuitem

```
-- 
```
```
--  'menuitem' 
```
```
-- 
```

--     * a Gtk.Menu_Item.Gtk_Menu_Item subclass, the exact type depends on the

```
--  action 
```
```
-- 
```
```
--  'toolitem' 
```
```
-- 
```

--     * a Gtk.Tool_Item.Gtk_Tool_Item subclass, the exact type depends on the

--  action. Note that toolitem elements may contain a menu element, but only if

--  their associated action specifies a

--  Gtk.Menu_Tool_Button.Gtk_Menu_Tool_Button as proxy.

```
-- 
```
```
--  'separator' 
```
```
-- 
```

--     * a Gtk.Separator_Menu_Item.Gtk_Separator_Menu_Item or

--  Gtk.Separator_Tool_Item.Gtk_Separator_Tool_Item

```
-- 
```
```
--  'accelerator' 
```
```
-- 
```
```
--     * a keyboard accelerator 
```
```
-- 
```

--  The "position" attribute determines where a constructed widget is

--  positioned wrt. to its siblings in the partially constructed tree. If it is

--  "top", the widget is prepended, otherwise it is appended.

```
-- 
```
```
--  == UI Merging == 
```
```
-- 
```

--  The most remarkable feature of Gtk.UI_Manager.Gtk_UI_Manager is that it

--  can overlay a set of menuitems and toolitems over another one, and demerge

```
--  them later. 
```
```
-- 
```

--  Merging is done based on the names of the XML elements. Each element is

--  identified by a path which consists of the names of its anchestors,

--  separated by slashes. For example, the menuitem named "Left" in the example

--  above has the path '/ui/menubar/JustifyMenu/Left' and the toolitem with the

--  same name has path '/ui/toolbar1/JustifyToolItems/Left'.

```
-- 
```
```
--  == Accelerators == 
```
```
-- 
```

--  Every action has an accelerator path. Accelerators are installed together

--  with menuitem proxies, but they can also be explicitly added with

--  <accelerator> elements in the UI definition. This makes it possible to have

--  accelerators for actions even if they have no visible proxies.

```
-- 
```
```
--  == Smart Separators == 
```
```
-- 
```

--  The separators created by Gtk.UI_Manager.Gtk_UI_Manager are "smart", i.e.

--  they do not show up in the UI unless they end up between two visible menu

--  or tool items. Separators which are located at the very beginning or end of

--  the menu or toolbar containing them, or multiple separators next to each

--  other, are hidden. This is a useful feature, since the merging of UI

--  elements from multiple sources can make it hard or impossible to determine

--  in advance whether a separator will end up in such an unfortunate position.

```
-- 
```

--  For separators in toolbars, you can set 'expand="true"' to turn them from

--  a small, visible separator to an expanding, invisible one. Toolitems

--  following an expanding separator are effectively right-aligned.

```
-- 
```
```
--  == Empty Menus == 
```
```
-- 
```

--  Submenus pose similar problems to separators inconnection with merging. It

--  is impossible to know in advance whether they will end up empty after

--  merging. Gtk.UI_Manager.Gtk_UI_Manager offers two ways to treat empty

```
--  submenus: 
```
```
-- 
```

--     * make them disappear by hiding the menu item they're attached to

```
-- 
```

--     * add an insensitive "Empty" item

```
-- 
```

--  The behaviour is chosen based on the "hide_if_empty" property of the

--  action to which the submenu is associated.

```
-- 
```
```
--  == GtkUIManager as GtkBuildable == 
```
```
-- 
```

--  The GtkUIManager implementation of the GtkBuildable interface accepts

--  GtkActionGroup objects as <child> elements in UI definitions.

```
-- 
```

--  A GtkUIManager UI definition as described above can be embedded in an

--  GtkUIManager <object> element in a GtkBuilder UI definition.

```
-- 
```

--  The widgets that are constructed by a GtkUIManager can be embedded in

--  other parts of the constructed user interface with the help of the

--  "constructor" attribute. See the example below.

```
-- 
```

--  == An embedded GtkUIManager UI definition ==

```
-- 
```

--    <object class="GtkUIManager" id="uiman">

```
--    <child> 
```

--    <object class="GtkActionGroup" id="actiongroup">

```
--    <child> 
```

--    <object class="GtkAction" id="file">

--    <property name="label">_File</property>

```
--    </object> 
```
```
--    </child> 
```
```
--    </object> 
```
```
--    </child> 
```
```
--    <ui> 
```
```
--    <menubar name="menubar1"> 
```
```
--    <menu action="file"> 
```
```
--    </menu> 
```
```
--    </menubar> 
```
```
--    </ui> 
```
```
--    </object> 
```

--    <object class="GtkWindow" id="main-window">

```
--    <child> 
```

--    <object class="GtkMenuBar" id="menubar1" constructor="uiman"/>

```
--    </child> 
```
```
--    </object> 
```
```
--  </description> 
```
```
pragma Ada_2005; 
```
```
 
```

pragma Warnings (Off, "*is already use-visible*");

with GlibTo API doc
To spec
To body;                    use GlibTo API doc
To spec
To body;

with Glib.ErrorTo API doc
To spec
To body;              use Glib.ErrorTo API doc
To spec
To body;

with Glib.Generic_PropertiesTo API doc
To spec
To body; use Glib.Generic_PropertiesTo API doc
To spec
To body;

with Glib.ObjectTo API doc
To spec
To body;             use Glib.ObjectTo API doc
To spec
To body;

with Glib.PropertiesTo API doc
To spec
To body;         use Glib.PropertiesTo API doc
To spec
To body;

with Glib.TypesTo API doc
To spec
To body;              use Glib.TypesTo API doc
To spec
To body;

with Gtk.Accel_GroupTo API doc
To spec
To body;         use Gtk.Accel_GroupTo API doc
To spec
To body;

with Gtk.ActionTo API doc
To spec
To body;              use Gtk.ActionTo API doc
To spec
To body;

with Gtk.Action_GroupTo API doc
To spec
To body;        use Gtk.Action_GroupTo API doc
To spec
To body;

with Gtk.BuildableTo API doc
To spec
To body;           use Gtk.BuildableTo API doc
To spec
To body;

with Gtk.WidgetTo API doc
To spec
To body;              use Gtk.WidgetTo API doc
To spec
To body;

```
 
```

package Gtk.UI_ManagerTo API doc
To spec
To body is

```
 
```

   type Gtk_UI_Manager_Record is new GObject_RecordTo API doc
To spec
To body with null record;

   type Gtk_UI_Manager is access all Gtk_UI_Manager_RecordTo API doc
To spec'Class;

```
 
```

   type Manager_Item_Type is mod 2 ** Integer'Size;

   pragma Convention (C, Manager_Item_TypeTo API doc
To spec);

   --  These enumeration values are used by Gtk.UI_Manager.Add_UI to determine

```
   --  what UI element to create. 
```
```
 
```

   Manager_Auto : constant Manager_Item_TypeTo API doc
To spec := 0;

   Manager_Menubar : constant Manager_Item_TypeTo API doc
To spec := 1;

   Manager_Menu : constant Manager_Item_TypeTo API doc
To spec := 2;

   Manager_Toolbar : constant Manager_Item_TypeTo API doc
To spec := 4;

   Manager_Placeholder : constant Manager_Item_TypeTo API doc
To spec := 8;

   Manager_Popup : constant Manager_Item_TypeTo API doc
To spec := 16;

   Manager_Menuitem : constant Manager_Item_TypeTo API doc
To spec := 32;

   Manager_Toolitem : constant Manager_Item_TypeTo API doc
To spec := 64;

   Manager_Separator : constant Manager_Item_TypeTo API doc
To spec := 128;

   Manager_Accelerator : constant Manager_Item_TypeTo API doc
To spec := 256;

   Manager_Popup_With_Accels : constant Manager_Item_TypeTo API doc
To spec := 512;

```
 
```
```
   ---------------------------- 
```
```
   -- Enumeration Properties -- 
```
```
   ---------------------------- 
```
```
 
```

   package Manager_Item_Type_Properties is

      new Generic_Internal_Discrete_PropertyTo API doc
To spec
To body (Manager_Item_TypeTo API doc
To spec);

   type Property_Manager_Item_Type is new Manager_Item_Type_Properties.PropertyTo API doc
To spec;

```
 
```
```
   ------------------ 
```
```
   -- Constructors -- 
```
```
   ------------------ 
```
```
 
```

   procedure Gtk_NewTo API doc
To body (Self : out Gtk_UI_ManagerTo API doc
To spec);

   procedure InitializeTo API doc
To body (Self : not null access Gtk_UI_Manager_RecordTo API doc
To spec'Class);

   --  Creates a new ui manager object.

```
   --  Since: gtk+ 2.4 
```
```
 
```

   function Gtk_UI_Manager_NewTo API doc
To body return Gtk_UI_ManagerTo API doc
To spec;

   --  Creates a new ui manager object.

```
   --  Since: gtk+ 2.4 
```
```
 
```

   function Get_TypeTo API doc
To body return Glib.GTypeTo API doc
To spec;

   pragma Import (C, Get_TypeTo API doc
To spec, "gtk_ui_manager_get_type");

```
 
```
```
   ------------- 
```
```
   -- Methods -- 
```
```
   ------------- 
```
```
 
```
```
   procedure Add_UITo API doc
To body 
```

      (Self     : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Merge_Id : GuintTo API doc
To spec;

       Path     : UTF8_StringTo API doc
To spec;

       Name     : UTF8_StringTo API doc
To spec;

       Action   : UTF8_StringTo API doc
To spec := "";

       The_Type : Manager_Item_TypeTo API doc
To spec := Manager_AutoTo API doc
To spec;

```
       Top      : Boolean := False); 
```

   --  Adds a UI element to the current contents of Manager.

   --  If Type is Gtk.UI_Manager.Manager_Auto, GTK+ inserts a menuitem,

   --  toolitem or separator if such an element can be inserted at the place

   --  determined by Path. Otherwise Type must indicate an element that can be

   --  inserted at the place determined by Path.

   --  If Path points to a menuitem or toolitem, the new element will be

   --  inserted before or after this item, depending on Top.

```
   --  Since: gtk+ 2.4 
```

   --  "merge_id": the merge id for the merged UI, see

```
   --  Gtk.UI_Manager.New_Merge_Id 
```
```
   --  "path": a path 
```

   --  "name": the name for the added UI element

   --  "action": the name of the action to be proxied, or null to add a

```
   --  separator 
```

   --  "type": the type of UI element to add.

   --  "top": if True, the UI element is added before its siblings, otherwise

```
   --  it is added after its siblings. 
```
```
 
```

   function Add_UI_From_FileTo API doc
To body

      (Self     : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Filename : UTF8_StringTo API doc
To spec;

       Error    : access Glib.Error.GErrorTo API doc
To spec) return GuintTo API doc
To spec;

   --  Parses a file containing a <link linkend="XML-UI">UI definition</link>

   --  and merges it with the current contents of Manager.

```
   --  Since: gtk+ 2.4 
```

   --  "filename": the name of the file to parse

```
 
```

   function Add_UI_From_ResourceTo API doc
To body

      (Self          : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Resource_Path : UTF8_StringTo API doc
To spec;

       Error         : access Glib.Error.GErrorTo API doc
To spec) return GuintTo API doc
To spec;

   --  Parses a resource file containing a <link linkend="XML-UI">UI

   --  definition</link> and merges it with the current contents of Manager.

```
   --  Since: gtk+ 3.4 
```

   --  "resource_path": the resource path of the file to parse

```
 
```

   function Add_UI_From_StringTo API doc
To body

      (Self   : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Buffer : UTF8_StringTo API doc
To spec;

       Error  : access Glib.Error.GErrorTo API doc
To spec) return GuintTo API doc
To spec;

   --  Parses a string containing a <link linkend="XML-UI">UI

   --  definition</link> and merges it with the current contents of Manager. An

   --  enclosing <ui> element is added if it is missing.

```
   --  Since: gtk+ 2.4 
```
```
   --  "buffer": the string to parse 
```
```
 
```

   procedure Ensure_UpdateTo API doc
To body (Self : not null access Gtk_UI_Manager_RecordTo API doc
To spec);

   --  Makes sure that all pending updates to the UI have been completed.

   --  This may occasionally be necessary, since Gtk.UI_Manager.Gtk_UI_Manager

   --  updates the UI in an idle function. A typical example where this

   --  function is useful is to enforce that the menubar and toolbar have been

   --  added to the main window before showing it: |[ gtk_container_add

   --  (GTK_CONTAINER (window), vbox); g_signal_connect (merge, "add-widget",

   --  G_CALLBACK (add_widget), vbox); gtk_ui_manager_add_ui_from_file (merge,

   --  "my-menus"); gtk_ui_manager_add_ui_from_file (merge, "my-toolbars");

   --  gtk_ui_manager_ensure_update (merge); gtk_widget_show (window); ]|

```
   --  Since: gtk+ 2.4 
```
```
 
```

   function Get_Accel_GroupTo API doc
To body

      (Self : not null access Gtk_UI_Manager_RecordTo API doc
To spec)

       return Gtk.Accel_Group.Gtk_Accel_GroupTo API doc
To spec;

   --  Returns the Gtk.Accel_Group.Gtk_Accel_Group associated with Manager.

```
   --  Since: gtk+ 2.4 
```
```
 
```

   function Get_ActionTo API doc
To body

      (Self : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Path : UTF8_StringTo API doc
To spec) return Gtk.Action.Gtk_ActionTo API doc
To spec;

   --  Looks up an action by following a path. See Gtk.UI_Manager.Get_Widget

   --  for more information about paths.

```
   --  Since: gtk+ 2.4 
```
```
   --  "path": a path 
```
```
 
```

   function Get_Action_GroupsTo API doc
To body

      (Self : not null access Gtk_UI_Manager_RecordTo API doc
To spec)

       return Glib.Object.Object_Simple_List.GlistTo API doc
To spec
To body;

   --  Returns the list of action groups associated with Manager.

```
   --  Since: gtk+ 2.4 
```
```
 
```

   function Get_Add_TearoffsTo API doc
To body

      (Self : not null access Gtk_UI_Manager_RecordTo API doc
To spec) return Boolean;

   pragma Obsolescent (Get_Add_TearoffsTo API doc
To spec
To body);

   --  Returns whether menus generated by this Gtk.UI_Manager.Gtk_UI_Manager

```
   --  will have tearoff menu items. 
```
```
   --  Since: gtk+ 2.4 
```

   --  Deprecated since 3.4, Tearoff menus are deprecated and should not be

```
   --  used in newly written code. 
```
```
 
```

   procedure Set_Add_TearoffsTo API doc
To body

      (Self         : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

```
       Add_Tearoffs : Boolean); 
```

   pragma Obsolescent (Set_Add_TearoffsTo API doc
To spec
To body);

   --  Sets the "add_tearoffs" property, which controls whether menus

   --  generated by this Gtk.UI_Manager.Gtk_UI_Manager will have tearoff menu

```
   --  items. 
```

   --  Note that this only affects regular menus. Generated popup menus never

```
   --  have tearoff menu items. 
```
```
   --  Since: gtk+ 2.4 
```

   --  Deprecated since 3.4, Tearoff menus are deprecated and should not be

```
   --  used in newly written code. 
```

   --  "add_tearoffs": whether tearoff menu items are added

```
 
```

   function Get_ToplevelsTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Types : Manager_Item_TypeTo API doc
To spec) return Gtk.Widget.Widget_SList.GSlistTo API doc
To spec
To body;

   --  Obtains a list of all toplevel widgets of the requested types.

```
   --  Since: gtk+ 2.4 
```

   --  "types": specifies the types of toplevel widgets to include. Allowed

   --  types are GTK_UI_MANAGER_MENUBAR, GTK_UI_MANAGER_TOOLBAR and

```
   --  GTK_UI_MANAGER_POPUP. 
```
```
 
```
```
   function Get_UiTo API doc
To body 
```

      (Self : not null access Gtk_UI_Manager_RecordTo API doc
To spec) return UTF8_StringTo API doc
To spec;

   --  Creates a <link linkend="XML-UI">UI definition</link> of the merged UI.

```
   --  Since: gtk+ 2.4 
```
```
 
```

   function Get_WidgetTo API doc
To body

      (Self : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Path : UTF8_StringTo API doc
To spec) return Gtk.Widget.Gtk_WidgetTo API doc
To spec;

   --  Looks up a widget by following a path. The path consists of the names

   --  specified in the XML description of the UI. separated by '/'. Elements

   --  which don't have a name or action attribute in the XML (e.g. <popup>)

   --  can be addressed by their XML element name (e.g. "popup"). The root

   --  element ("/ui") can be omitted in the path.

   --  Note that the widget found by following a path that ends in a <menu>

   --  element is the menuitem to which the menu is attached, not the menu

```
   --  itmanager. 
```

   --  Also note that the widgets constructed by a ui manager are not tied to

   --  the lifecycle of the ui manager. If you add the widgets returned by this

   --  function to some container or explicitly ref them, they will survive the

```
   --  destruction of the ui manager. 
```
```
   --  Since: gtk+ 2.4 
```
```
   --  "path": a path 
```
```
 
```

   procedure Insert_Action_GroupTo API doc
To body

      (Self         : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Action_Group : not null access Gtk.Action_Group.Gtk_Action_Group_RecordTo API doc
To spec'Class;

       Pos          : GintTo API doc
To spec);

   --  Inserts an action group into the list of action groups associated with

   --  Manager. Actions in earlier groups hide actions with the same name in

```
   --  later groups. 
```

   --  If Pos is larger than the number of action groups in Manager, or

   --  negative, Action_Group will be inserted at the end of the internal list.

```
   --  Since: gtk+ 2.4 
```

   --  "action_group": the action group to be inserted

   --  "pos": the position at which the group will be inserted.

```
 
```

   function New_Merge_IdTo API doc
To body

      (Self : not null access Gtk_UI_Manager_RecordTo API doc
To spec) return GuintTo API doc
To spec;

   --  Returns an unused merge id, suitable for use with

```
   --  Gtk.UI_Manager.Add_UI. 
```
```
   --  Since: gtk+ 2.4 
```
```
 
```

   procedure Remove_Action_GroupTo API doc
To body

      (Self         : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Action_Group : not null access Gtk.Action_Group.Gtk_Action_Group_RecordTo API doc
To spec'Class);

   --  Removes an action group from the list of action groups associated with

```
   --  Manager. 
```
```
   --  Since: gtk+ 2.4 
```

   --  "action_group": the action group to be removed

```
 
```

   procedure Remove_UITo API doc
To body

      (Self     : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Merge_Id : GuintTo API doc
To spec);

   --  Unmerges the part of Manager<!-- -->s content identified by Merge_Id.

```
   --  Since: gtk+ 2.4 
```

   --  "merge_id": a merge id as returned by Gtk.UI_Manager.Add_UI_From_String

```
 
```
```
   ---------------- 
```
```
   -- Properties -- 
```
```
   ---------------- 
```

   --  The following properties are defined for this widget. See

   --  Glib.Properties for more information on properties)

```
 
```

   Add_Tearoffs_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

   --  The "add-tearoffs" property controls whether generated menus have

```
   --  tearoff menu items. 
```
```
   -- 
```

   --  Note that this only affects regular menus. Generated popup menus never

```
   --  have tearoff menu items. 
```
```
 
```

   Ui_Property : constant Glib.Properties.Property_StringTo API doc
To spec;

```
 
```
```
   ------------- 
```
```
   -- Signals -- 
```
```
   ------------- 
```
```
 
```

   type Cb_Gtk_UI_Manager_Void is not null access procedure (Self : access Gtk_UI_Manager_RecordTo API doc
To spec'Class);

```
 
```

   type Cb_GObject_Void is not null access procedure

     (Self : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class);

```
 
```

   Signal_Actions_Changed : constant Glib.Signal_NameTo API doc
To spec := "actions-changed";

   procedure On_Actions_ChangedTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Call  : Cb_Gtk_UI_Manager_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Actions_ChangedTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Call  : Cb_GObject_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::actions-changed signal is emitted whenever the set of actions

```
   --  changes. 
```
```
 
```

   type Cb_Gtk_UI_Manager_Gtk_Widget_Void is not null access procedure

     (Self   : access Gtk_UI_Manager_RecordTo API doc
To spec'Class;

      Widget : not null access Gtk.Widget.Gtk_Widget_RecordTo API doc
To spec'Class);

```
 
```

   type Cb_GObject_Gtk_Widget_Void is not null access procedure

     (Self   : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Widget : not null access Gtk.Widget.Gtk_Widget_RecordTo API doc
To spec'Class);

```
 
```

   Signal_Add_Widget : constant Glib.Signal_NameTo API doc
To spec := "add-widget";

   procedure On_Add_WidgetTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Call  : Cb_Gtk_UI_Manager_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Add_WidgetTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Widget_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::add-widget signal is emitted for each generated menubar and

   --  toolbar. It is not emitted for generated popup menus, which can be

   --  obtained by Gtk.UI_Manager.Get_Widget.

```
 
```

   type Cb_Gtk_UI_Manager_Gtk_Action_Gtk_Widget_Void is not null access procedure

     (Self   : access Gtk_UI_Manager_RecordTo API doc
To spec'Class;

      Action : not null access Gtk.Action.Gtk_Action_RecordTo API doc
To spec'Class;

      Proxy  : not null access Gtk.Widget.Gtk_Widget_RecordTo API doc
To spec'Class);

```
 
```

   type Cb_GObject_Gtk_Action_Gtk_Widget_Void is not null access procedure

     (Self   : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Action : not null access Gtk.Action.Gtk_Action_RecordTo API doc
To spec'Class;

      Proxy  : not null access Gtk.Widget.Gtk_Widget_RecordTo API doc
To spec'Class);

```
 
```

   Signal_Connect_Proxy : constant Glib.Signal_NameTo API doc
To spec := "connect-proxy";

   procedure On_Connect_ProxyTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Call  : Cb_Gtk_UI_Manager_Gtk_Action_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Connect_ProxyTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Action_Gtk_Widget_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::connect-proxy signal is emitted after connecting a proxy to an

```
   --  action in the group. 
```
```
   -- 
```

   --  This is intended for simple customizations for which a custom action

   --  class would be too clumsy, e.g. showing tooltips for menuitems in the

```
   --  statusbar. 
```
```
   --  
```
```
   --  Callback parameters: 
```
```
   --    --  "action": the action 
```
```
   --    --  "proxy": the proxy 
```
```
 
```

   Signal_Disconnect_Proxy : constant Glib.Signal_NameTo API doc
To spec := "disconnect-proxy";

   procedure On_Disconnect_ProxyTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Call  : Cb_Gtk_UI_Manager_Gtk_Action_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Disconnect_ProxyTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Action_Gtk_Widget_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::disconnect-proxy signal is emitted after disconnecting a proxy

```
   --  from an action in the group. 
```
```
   --  
```
```
   --  Callback parameters: 
```
```
   --    --  "action": the action 
```
```
   --    --  "proxy": the proxy 
```
```
 
```

   type Cb_Gtk_UI_Manager_Gtk_Action_Void is not null access procedure

     (Self   : access Gtk_UI_Manager_RecordTo API doc
To spec'Class;

      Action : not null access Gtk.Action.Gtk_Action_RecordTo API doc
To spec'Class);

```
 
```

   type Cb_GObject_Gtk_Action_Void is not null access procedure

     (Self   : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Action : not null access Gtk.Action.Gtk_Action_RecordTo API doc
To spec'Class);

```
 
```

   Signal_Post_Activate : constant Glib.Signal_NameTo API doc
To spec := "post-activate";

   procedure On_Post_ActivateTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Call  : Cb_Gtk_UI_Manager_Gtk_Action_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Post_ActivateTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Action_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::post-activate signal is emitted just after the Action is

```
   --  activated. 
```
```
   -- 
```

   --  This is intended for applications to get notification just after any

```
   --  action is activated. 
```
```
 
```

   Signal_Pre_Activate : constant Glib.Signal_NameTo API doc
To spec := "pre-activate";

   procedure On_Pre_ActivateTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Call  : Cb_Gtk_UI_Manager_Gtk_Action_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Pre_ActivateTo API doc
To body

      (Self  : not null access Gtk_UI_Manager_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Action_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::pre-activate signal is emitted just before the Action is

```
   --  activated. 
```
```
   -- 
```

   --  This is intended for applications to get notification just before any

```
   --  action is activated. 
```
```
 
```
```
   ---------------- 
```
```
   -- Interfaces -- 
```
```
   ---------------- 
```

   --  This class implements several interfaces. See Glib.Types

```
   -- 
```
```
   --  - "Buildable" 
```
```
 
```

   package Implements_Gtk_Buildable is new Glib.Types.ImplementsTo API doc
To spec
To body

     (Gtk.Buildable.Gtk_BuildableTo API doc
To spec, Gtk_UI_Manager_RecordTo API doc
To spec, Gtk_UI_ManagerTo API doc
To spec);

```
   function "+" 
```

     (Widget : access Gtk_UI_Manager_RecordTo API doc
To spec'Class)

   return Gtk.Buildable.Gtk_BuildableTo API doc
To spec

   renames Implements_Gtk_Buildable.To_InterfaceTo API doc
To spec
To body;

```
   function "-" 
```

     (Interf : Gtk.Buildable.Gtk_BuildableTo API doc
To spec)

   return Gtk_UI_ManagerTo API doc
To spec

   renames Implements_Gtk_Buildable.To_ObjectTo API doc
To spec
To body;

```
 
```
```
private 
```

   Ui_PropertyTo API doc
To spec : constant Glib.Properties.Property_StringTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("ui");

   Add_Tearoffs_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("add-tearoffs");

end Gtk.UI_ManagerTo API doc
To spec
To body;

Documentation