File: gtk-container.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+ user interface is constructed by nesting widgets inside widgets.

--  Container widgets are the inner nodes in the resulting tree of widgets:

--  they contain other widgets. So, for example, you might have a

--  Gtk.Window.Gtk_Window containing a Gtk.Frame.Gtk_Frame containing a

--  Gtk.Label.Gtk_Label. If you wanted an image instead of a textual label

--  inside the frame, you might replace the Gtk.Label.Gtk_Label widget with a

```
--  Gtk.Image.Gtk_Image widget. 
```
```
-- 
```

--  There are two major kinds of container widgets in GTK+. Both are

--  subclasses of the abstract GtkContainer base class.

```
-- 
```

--  The first type of container widget has a single child widget and derives

--  from Gtk.Bin.Gtk_Bin. These containers are *decorators*, which add some

--  kind of functionality to the child. For example, a Gtk.Button.Gtk_Button

--  makes its child into a clickable button; a Gtk.Frame.Gtk_Frame draws a

--  frame around its child and a Gtk.Window.Gtk_Window places its child widget

```
--  inside a top-level window. 
```
```
-- 
```

--  The second type of container can have more than one child; its purpose is

--  to manage *layout*. This means that these containers assign sizes and

--  positions to their children. For example, a Gtk.Box.Gtk_Hbox arranges its

--  children in a horizontal row, and a Gtk.Grid.Gtk_Grid arranges the widgets

--  it contains in a two-dimensional grid.

```
-- 
```

--  == Height for width geometry management ==

```
-- 
```

--  GTK+ uses a height-for-width (and width-for-height) geometry management

--  system. Height-for-width means that a widget can change how much vertical

--  space it needs, depending on the amount of horizontal space that it is

--  given (and similar for width-for-height).

```
-- 
```

--  There are some things to keep in mind when implementing container widgets

--  that make use of GTK+'s height for width geometry management system. First,

--  it's important to note that a container must prioritize one of its

--  dimensions, that is to say that a widget or container can only have a

--  Gtk.Enums.Gtk_Size_Request_Mode that is Gtk.Enums.Height_For_Width or

--  Gtk.Enums.Width_For_Height. However, every widget and container must be

--  able to respond to the APIs for both dimensions, i.e. even if a widget has

--  a request mode that is height-for-width, it is possible that its parent

--  will request its sizes using the width-for-height APIs.

```
-- 
```

--  To ensure that everything works properly, here are some guidelines to

--  follow when implementing height-for-width (or width-for-height) containers.

```
-- 
```

--  Each request mode involves 2 virtual methods. Height-for-width apis run

--  through Gtk.Widget.Get_Preferred_Width and then through

--  Gtk.Widget.Get_Preferred_Height_For_Width. When handling requests in the

--  opposite Gtk.Enums.Gtk_Size_Request_Mode it is important that every widget

--  request at least enough space to display all of its content at all times.

```
-- 
```

--  When Gtk.Widget.Get_Preferred_Height is called on a container that is

--  height-for-width, the container must return the height for its minimum

--  width. This is easily achieved by simply calling the reverse apis

```
--  implemented for itself as follows: 
```
```
-- 
```
```
--    static void 
```

--    foo_container_get_preferred_height (GtkWidget *widget, gint *min_height, gint *nat_height)

```
--    { 
```

--       if (i_am_in_height_for_width_mode)

```
--       { 
```
```
--          gint min_width; 
```

--          GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL);

--          GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_width,

--             min_height, nat_height);

```
--       } 
```
```
--    else 
```
```
--       { 
```

--          ... many containers support both request modes, execute the real width-for-height

--          request here by returning the collective heights of all widgets that are

--          stacked vertically (or whatever is appropriate for this container) ...

```
--       } 
```
```
--    } 
```
```
-- 
```

--  Similarly, when Gtk.Widget.Get_Preferred_Width_For_Height is called for a

--  container or widget that is height-for-width, it then only needs to return

```
--  the base minimum width like so: 
```
```
-- 
```
```
--    static void 
```

--    foo_container_get_preferred_width_for_height (GtkWidget *widget, gint for_height,

--       gint *min_width, gint *nat_width)

```
--    { 
```

--       if (i_am_in_height_for_width_mode)

```
--       { 
```

--          GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, min_width, nat_width);

```
--       } 
```
```
--    else 
```
```
--       { 
```

--          ... execute the real width-for-height request here based on the required width

--          of the children collectively if the container were to be allocated the said height ...

```
--       } 
```
```
--    } 
```
```
-- 
```

--  Height for width requests are generally implemented in terms of a virtual

--  allocation of widgets in the input orientation. Assuming an

--  height-for-width request mode, a container would implement the

--  <function>get_preferred_height_for_width</function> virtual function by

--  first calling Gtk.Widget.Get_Preferred_Width for each of its children.

```
-- 
```

--  For each potential group of children that are lined up horizontally, the

--  values returned by Gtk.Widget.Get_Preferred_Width should be collected in an

--  array of Gtk_Requested_Size structures. Any child spacing should be removed

--  from the input For_Width and then the collective size should be allocated

--  using the gtk_distribute_natural_allocation convenience function.

```
-- 
```

--  The container will then move on to request the preferred height for each

--  child by using Gtk.Widget.Get_Preferred_Height_For_Width and using the

--  sizes stored in the Gtk_Requested_Size array.

```
-- 
```

--  To allocate a height-for-width container, it's again important to consider

--  that a container must prioritize one dimension over the other. So if a

--  container is a height-for-width container it must first allocate all

--  widgets horizontally using a Gtk_Requested_Size array and

--  gtk_distribute_natural_allocation and then add any extra space (if and

--  where appropriate) for the widget to expand.

```
-- 
```

--  After adding all the expand space, the container assumes it was allocated

--  sufficient height to fit all of its content. At this time, the container

--  must use the total horizontal sizes of each widget to request the

--  height-for-width of each of its children and store the requests in a

--  Gtk_Requested_Size array for any widgets that stack vertically (for tabular

--  containers this can be generalized into the heights and widths of rows and

--  columns). The vertical space must then again be distributed using

--  gtk_distribute_natural_allocation while this time considering the allocated

--  height of the widget minus any vertical spacing that the container adds.

--  Then vertical expand space should be added where appropriate and available

--  and the container should go on to actually allocating the child widgets.

```
-- 
```

--  See <link linkend="geometry-management">GtkWidget's geometry management

--  section</link> to learn more about implementing height-for-width geometry

```
--  management for widgets. 
```
```
-- 
```
```
--  == Child properties == 
```
```
-- 
```

--  GtkContainer introduces *child properties*. These are object properties

--  that are not specific to either the container or the contained widget, but

--  rather to their relation. Typical examples of child properties are the

--  position or pack-type of a widget which is contained in a Gtk.Box.Gtk_Box.

```
-- 
```

--  Use gtk_container_class_install_child_property to install child properties

--  for a container class and gtk_container_class_find_child_property or

--  gtk_container_class_list_child_properties to get information about existing

```
--  child properties. 
```
```
-- 
```

--  To set the value of a child property, use

--  Gtk.Container.Child_Set_Property, gtk_container_child_set or

--  gtk_container_child_set_valist. To obtain the value of a child property,

--  use Gtk.Container.Child_Get_Property, gtk_container_child_get or

--  gtk_container_child_get_valist. To emit notification about child property

--  changes, use Gtk.Widget.Child_Notify.

```
-- 
```
```
--  == GtkContainer as GtkBuildable == 
```
```
-- 
```

--  The GtkContainer implementation of the GtkBuildable interface supports a

--  <packing> element for children, which can contain multiple <property>

--  elements that specify child properties for the child.

```
-- 
```

--  == Child properties in UI definitions ==

```
-- 
```
```
--    <object class="GtkVBox"> 
```
```
--    <child> 
```
```
--    <object class="GtkLabel"/> 
```
```
--    <packing> 
```

--    <property name="pack-type">start</property>

```
--    </packing> 
```
```
--    </child> 
```
```
--    </object> 
```

--  Since 2.16, child properties can also be marked as translatable using the

--  same "translatable", "comments" and "context" attributes that are used for

```
--  regular properties. 
```
```
-- 
```
```
-- 
```
```
--  </description> 
```
```
pragma Ada_2005; 
```
```
 
```

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

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

with GlibTo API doc
To spec
To body;            use GlibTo 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 Glib.ValuesTo API doc
To spec
To body;     use Glib.ValuesTo API doc
To spec
To body;

with Gtk.AdjustmentTo API doc
To spec
To body;  use Gtk.AdjustmentTo 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.EnumsTo API doc
To spec
To body;       use Gtk.EnumsTo 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.ContainerTo API doc
To spec
To body is

```
 
```

   type Gtk_Container_Record is new Gtk_Widget_RecordTo API doc
To spec with null record;

   type Gtk_Container is access all Gtk_Container_RecordTo API doc
To spec'Class;

```
 
```
```
   --------------- 
```
```
   -- Callbacks -- 
```
```
   --------------- 
```
```
 
```

   type Gtk_Callback is access procedure

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

   --  The type of the callback functions used for e.g. iterating over the

   --  children of a container, see gtk_container_foreach.

   --  "widget": the widget to operate on

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

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

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

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

      (Container : not null access Gtk_Container_RecordTo API doc
To spec;

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

   --  Adds Widget to Container. Typically used for simple containers such as

   --  Gtk.Window.Gtk_Window, Gtk.Frame.Gtk_Frame, or Gtk.Button.Gtk_Button;

   --  for more complicated layout containers such as Gtk.Box.Gtk_Box or

   --  Gtk.Grid.Gtk_Grid, this function will pick default packing parameters

   --  that may not be correct. So consider functions such as

   --  Gtk.Box.Pack_Start and Gtk.Grid.Attach as an alternative to

   --  Gtk.Container.Add in those cases. A widget may be added to only one

   --  container at a time; you can't place the same widget inside two

```
   --  different containers. 
```

   --  "widget": a widget to be placed inside Container

```
 
```

   procedure Check_ResizeTo API doc
To body (Container : not null access Gtk_Container_RecordTo API doc
To spec);

```
 
```

   procedure Child_Get_PropertyTo API doc
To body

      (Container     : not null access Gtk_Container_RecordTo API doc
To spec;

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

       Property_Name : UTF8_StringTo API doc
To spec;

       ValueTo API doc
To body         : in out Glib.Values.GValueTo API doc
To spec
To body);

   --  Gets the value of a child property for Child and Container.

   --  "child": a widget which is a child of Container

   --  "property_name": the name of the property to get

   --  "value": a location to return the value

```
 
```

   procedure Child_Set_PropertyTo API doc
To body

      (Container     : not null access Gtk_Container_RecordTo API doc
To spec;

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

       Property_Name : UTF8_StringTo API doc
To spec;

       ValueTo API doc
To body         : Glib.Values.GValueTo API doc
To spec
To body);

   --  Sets a child property for Child and Container.

   --  "child": a widget which is a child of Container

   --  "property_name": the name of the property to set

   --  "value": the value to set the property to

```
 
```

   procedure Child_NotifyTo API doc
To body

      (Container      : not null access Gtk_Container_RecordTo API doc
To spec;

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

       Child_Property : UTF8_StringTo API doc
To spec);

   --  Emits a Gtk.Widget.Gtk_Widget::child-notify signal for the <link

   --  linkend="child-properties">child property</link> Child_Property on

```
   --  widget. 
```

   --  This is an analogue of g_object_notify for child properties.

   --  Also see Gtk.Widget.Child_Notify.

```
   --  Since: gtk+ 3.2 
```
```
   --  "child": the child widget 
```

   --  "child_property": the name of a child property installed on the class

```
   --  of Container 
```
```
 
```

   function Child_TypeTo API doc
To body

      (Container : not null access Gtk_Container_RecordTo API doc
To spec) return GTypeTo API doc
To spec;

   --  Returns the type of the children supported by the container.

   --  Note that this may return G_TYPE_NONE to indicate that no more children

   --  can be added, e.g. for a Gtk.Paned.Gtk_Paned which already has two

```
   --  children. 
```
```
 
```
```
   procedure ForallTo API doc
To body 
```

      (Container : not null access Gtk_Container_RecordTo API doc
To spec;

       Callback  : Gtk_CallbackTo API doc
To spec);

   --  Invokes Callback on each child of Container, including children that

   --  are considered "internal" (implementation details of the container).

   --  "Internal" children generally weren't added by the user of the

   --  container, but were added by the container implementation itself. Most

   --  applications should use Gtk.Container.Foreach, rather than

```
   --  Gtk.Container.Forall. 
```
```
   --  "callback": a callback 
```
```
 
```
```
   generic 
```

      type User_Data_Type (<>) is private;

      with procedure Destroy (Data : in out User_Data_TypeTo API doc
To spec) is null;

   package Forall_User_DataTo API doc
To body is

```
 
```

      type Gtk_Callback is access procedure

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

         Data   : User_Data_TypeTo API doc
To spec);

      --  The type of the callback functions used for e.g. iterating over the

      --  children of a container, see gtk_container_foreach.

      --  "widget": the widget to operate on

```
      --  "data": user-supplied data 
```
```
 
```

      procedure ForallTo API doc
To body

         (Container     : not null access Gtk.Container.Gtk_Container_RecordTo API doc
To spec'Class;

          Callback      : Gtk_CallbackTo API doc
To spec;

          Callback_Data : User_Data_TypeTo API doc
To spec);

      --  Invokes Callback on each child of Container, including children that

      --  are considered "internal" (implementation details of the container).

      --  "Internal" children generally weren't added by the user of the

      --  container, but were added by the container implementation itself.

      --  Most applications should use Gtk.Container.Foreach, rather than

```
      --  Gtk.Container.Forall. 
```
```
      --  "callback": a callback 
```

      --  "callback_data": callback user data

```
 
```

   end Forall_User_DataTo API doc
To spec
To body;

```
 
```
```
   procedure ForeachTo API doc
To body 
```

      (Container : not null access Gtk_Container_RecordTo API doc
To spec;

       Callback  : Gtk_CallbackTo API doc
To spec);

   --  Invokes Callback on each non-internal child of Container. See

   --  Gtk.Container.Forall for details on what constitutes an "internal"

   --  child. Most applications should use Gtk.Container.Foreach, rather than

```
   --  Gtk.Container.Forall. 
```
```
   --  "callback": a callback 
```
```
 
```
```
   generic 
```

      type User_Data_Type (<>) is private;

      with procedure Destroy (Data : in out User_Data_TypeTo API doc
To spec) is null;

   package Foreach_User_DataTo API doc
To body is

```
 
```

      type Gtk_Callback is access procedure

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

         Data   : User_Data_TypeTo API doc
To spec);

      --  The type of the callback functions used for e.g. iterating over the

      --  children of a container, see Gtk.Container.Foreach.

      --  "widget": the widget to operate on

```
      --  "data": user-supplied data 
```
```
 
```

      procedure ForeachTo API doc
To body

         (Container     : not null access Gtk.Container.Gtk_Container_RecordTo API doc
To spec'Class;

          Callback      : Gtk_CallbackTo API doc
To spec;

          Callback_Data : User_Data_TypeTo API doc
To spec);

      --  Invokes Callback on each non-internal child of Container. See

      --  Gtk.Container.Forall for details on what constitutes an "internal"

      --  child. Most applications should use Gtk.Container.Foreach, rather

```
      --  than Gtk.Container.Forall. 
```
```
      --  "callback": a callback 
```

      --  "callback_data": callback user data

```
 
```

   end Foreach_User_DataTo API doc
To spec
To body;

```
 
```

   function Get_Border_WidthTo API doc
To body

      (Container : not null access Gtk_Container_RecordTo API doc
To spec) return GuintTo API doc
To spec;

   --  Retrieves the border width of the container. See

```
   --  Gtk.Container.Set_Border_Width. 
```
```
 
```

   procedure Set_Border_WidthTo API doc
To body

      (Container    : not null access Gtk_Container_RecordTo API doc
To spec;

       Border_Width : GuintTo API doc
To spec);

   --  Sets the border width of the container.

   --  The border width of a container is the amount of space to leave around

   --  the outside of the container. The only exception to this is

   --  Gtk.Window.Gtk_Window; because toplevel windows can't leave space

   --  outside, they leave the space inside. The border is added on all sides

   --  of the container. To add space to only one side, one approach is to

   --  create a Gtk.Alignment.Gtk_Alignment widget, call

   --  Gtk.Widget.Set_Size_Request to give it a size, and place it on the side

```
   --  of the container as a spacer. 
```

   --  "border_width": amount of blank space to leave *outside* the container.

   --  Valid values are in the range 0-65535 pixels.

```
 
```

   function Get_ChildrenTo API doc
To body

      (Container : not null access Gtk_Container_RecordTo API doc
To spec)

       return Gtk.Widget.Widget_List.GlistTo API doc
To spec
To body;

   --  Returns the container's non-internal children. See Gtk.Container.Forall

   --  for details on what constitutes an "internal" child.

```
 
```

   function Get_Focus_ChildTo API doc
To body

      (Container : not null access Gtk_Container_RecordTo API doc
To spec)

       return Gtk.Widget.Gtk_WidgetTo API doc
To spec;

   --  Returns the current focus child widget inside Container. This is not

   --  the currently focused widget. That can be obtained by calling

```
   --  Gtk.Window.Get_Focus. 
```
```
   --  Since: gtk+ 2.14 
```
```
 
```

   procedure Set_Focus_ChildTo API doc
To body

      (Container : not null access Gtk_Container_RecordTo API doc
To spec;

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

   --  Sets, or unsets if Child is null, the focused child of Container.

   --  This function emits the GtkContainer::set_focus_child signal of

   --  Container. Implementations of Gtk.Container.Gtk_Container can override

   --  the default behaviour by overriding the class closure of this signal.

   --  This is function is mostly meant to be used by widgets. Applications

   --  can use Gtk.Widget.Grab_Focus to manualy set the focus to a specific

```
   --  widget. 
```

   --  "child": a Gtk.Widget.Gtk_Widget, or null

```
 
```

   function Get_Focus_HadjustmentTo API doc
To body

      (Container : not null access Gtk_Container_RecordTo API doc
To spec)

       return Gtk.Adjustment.Gtk_AdjustmentTo API doc
To spec;

   --  Retrieves the horizontal focus adjustment for the container. See

   --  gtk_container_set_focus_hadjustment ().

```
 
```

   procedure Set_Focus_HadjustmentTo API doc
To body

      (Container  : not null access Gtk_Container_RecordTo API doc
To spec;

       Adjustment : not null access Gtk.Adjustment.Gtk_Adjustment_RecordTo API doc
To spec'Class);

   --  Hooks up an adjustment to focus handling in a container, so when a

   --  child of the container is focused, the adjustment is scrolled to show

   --  that widget. This function sets the horizontal alignment. See

   --  Gtk.Scrolled_Window.Get_Hadjustment for a typical way of obtaining the

   --  adjustment and Gtk.Container.Set_Focus_Vadjustment for setting the

```
   --  vertical adjustment. 
```

   --  The adjustments have to be in pixel units and in the same coordinate

   --  system as the allocation for immediate children of the container.

   --  "adjustment": an adjustment which should be adjusted when the focus is

   --  moved among the descendents of Container

```
 
```

   function Get_Focus_VadjustmentTo API doc
To body

      (Container : not null access Gtk_Container_RecordTo API doc
To spec)

       return Gtk.Adjustment.Gtk_AdjustmentTo API doc
To spec;

   --  Retrieves the vertical focus adjustment for the container. See

   --  Gtk.Container.Set_Focus_Vadjustment.

```
 
```

   procedure Set_Focus_VadjustmentTo API doc
To body

      (Container  : not null access Gtk_Container_RecordTo API doc
To spec;

       Adjustment : not null access Gtk.Adjustment.Gtk_Adjustment_RecordTo API doc
To spec'Class);

   --  Hooks up an adjustment to focus handling in a container, so when a

   --  child of the container is focused, the adjustment is scrolled to show

   --  that widget. This function sets the vertical alignment. See

   --  Gtk.Scrolled_Window.Get_Vadjustment for a typical way of obtaining the

   --  adjustment and Gtk.Container.Set_Focus_Hadjustment for setting the

```
   --  horizontal adjustment. 
```

   --  The adjustments have to be in pixel units and in the same coordinate

   --  system as the allocation for immediate children of the container.

   --  "adjustment": an adjustment which should be adjusted when the focus is

   --  moved among the descendents of Container

```
 
```

   function Get_Path_For_ChildTo API doc
To body

      (Container : not null access Gtk_Container_RecordTo API doc
To spec;

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

       return Gtk.Widget.Gtk_Widget_PathTo API doc
To spec;

   --  Returns a newly created widget path representing all the widget

   --  hierarchy from the toplevel down to and including Child.

```
   --  "child": a child of Container 
```
```
 
```

   function Get_Resize_ModeTo API doc
To body

      (Container : not null access Gtk_Container_RecordTo API doc
To spec)

       return Gtk.Enums.Gtk_Resize_ModeTo API doc
To spec;

   --  Returns the resize mode for the container. See

   --  gtk_container_set_resize_mode ().

```
 
```

   procedure Set_Resize_ModeTo API doc
To body

      (Container   : not null access Gtk_Container_RecordTo API doc
To spec;

       Resize_ModeTo API doc
To body : Gtk.Enums.Gtk_Resize_ModeTo API doc
To spec);

   --  Sets the resize mode for the container.

   --  The resize mode of a container determines whether a resize request will

   --  be passed to the container's parent, queued for later execution or

```
   --  executed immediately. 
```

   --  "resize_mode": the new resize mode

```
 
```

   procedure Propagate_DrawTo API doc
To body

      (Container : not null access Gtk_Container_RecordTo API doc
To spec;

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

       Cr        : Cairo.Cairo_ContextTo API doc
To spec);

   --  When a container receives a call to the draw function, it must send

   --  synthetic Gtk.Widget.Gtk_Widget::draw calls to all children that don't

   --  have their own Gdk_Windows. This function provides a convenient way of

   --  doing this. A container, when it receives a call to its

   --  Gtk.Widget.Gtk_Widget::draw function, calls Gtk.Container.Propagate_Draw

   --  once for each child, passing in the Cr the container received.

   --  Gtk.Container.Propagate_Draw takes care of translating the origin of

   --  Cr, and deciding whether the draw needs to be sent to the child. It is a

   --  convenient and optimized way of getting the same effect as calling

   --  Gtk.Widget.Draw on the child directly.

   --  In most cases, a container can simply either inherit the

   --  Gtk.Widget.Gtk_Widget::draw implementation from

   --  Gtk.Container.Gtk_Container, or do some drawing and then chain to the

   --  ::draw implementation from Gtk.Container.Gtk_Container.

```
   --  "child": a child of Container 
```

   --  "cr": Cairo context as passed to the container. If you want to use Cr

   --  in container's draw function, consider using cairo_save and

   --  cairo_restore before calling this function.

```
 
```
```
   procedure RemoveTo API doc
To body 
```

      (Container : not null access Gtk_Container_RecordTo API doc
To spec;

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

   --  Removes Widget from Container. Widget must be inside Container. Note

   --  that Container will own a reference to Widget, and that this may be the

   --  last reference held; so removing a widget from its container can destroy

   --  that widget. If you want to use Widget again, you need to add a

   --  reference to it while it's not inside a container, using g_object_ref.

   --  If you don't want to use Widget again it's usually more efficient to

   --  simply destroy it directly using Gtk.Widget.Destroy since this will

   --  remove it from the container and help break any circular reference count

```
   --  cycles. 
```

   --  "widget": a current child of Container

```
 
```

   procedure Resize_ChildrenTo API doc
To body

      (Container : not null access Gtk_Container_RecordTo API doc
To spec);

```
 
```

   procedure Set_Focus_ChainTo API doc
To body

      (Container         : not null access Gtk_Container_RecordTo API doc
To spec;

       Focusable_WidgetsTo API doc
To body : Gtk.Widget.Widget_List.GlistTo API doc
To spec
To body);

   --  Sets a focus chain, overriding the one computed automatically by GTK+.

   --  In principle each widget in the chain should be a descendant of the

   --  container, but this is not enforced by this method, since it's allowed

   --  to set the focus chain before you pack the widgets, or have a widget in

   --  the chain that isn't always packed. The necessary checks are done when

   --  the focus chain is actually traversed.

   --  "focusable_widgets": the new focus chain

```
 
```

   procedure Set_Reallocate_RedrawsTo API doc
To body

      (Container     : not null access Gtk_Container_RecordTo API doc
To spec;

```
       Needs_Redraws : Boolean); 
```

   --  Sets the Reallocate_Redraws flag of the container to the given value.

   --  Containers requesting reallocation redraws get automatically redrawn if

   --  any of their children changed allocation.

   --  "needs_redraws": the new value for the container's Reallocate_Redraws

```
   --  flag 
```
```
 
```

   procedure Unset_Focus_ChainTo API doc
To body

      (Container : not null access Gtk_Container_RecordTo API doc
To spec);

   --  Removes a focus chain explicitly set with

```
   --  Gtk.Container.Set_Focus_Chain. 
```
```
 
```
```
   ---------------- 
```
```
   -- Properties -- 
```
```
   ---------------- 
```

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

   --  Glib.Properties for more information on properties)

```
 
```

   Border_Width_Property : constant Glib.Properties.Property_UintTo API doc
To spec;

```
 
```

   Child_Property : constant Glib.Properties.Property_ObjectTo API doc
To spec;

```
   --  Type: Gtk.Widget.Gtk_Widget 
```
```
   --  Flags: write 
```
```
 
```

   Resize_Mode_Property : constant Gtk.Enums.Property_Gtk_Resize_ModeTo API doc
To spec;

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

   type Cb_Gtk_Container_Gtk_Widget_Void is not null access procedure

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

      Object : 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;

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

```
 
```

   Signal_Add : constant Glib.Signal_NameTo API doc
To spec := "add";

```
   procedure On_AddTo API doc
To body 
```

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

       Call  : Cb_Gtk_Container_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```
```
   procedure On_AddTo API doc
To body 
```

      (Self  : not null access Gtk_Container_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); 
```
```
 
```

   type Cb_Gtk_Container_Void is not null access procedure (Self : access Gtk_Container_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_Check_Resize : constant Glib.Signal_NameTo API doc
To spec := "check-resize";

   procedure On_Check_ResizeTo API doc
To body

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

       Call  : Cb_Gtk_Container_VoidTo API doc
To spec;

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

   procedure On_Check_ResizeTo API doc
To body

      (Self  : not null access Gtk_Container_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); 
```
```
 
```

   Signal_Remove : constant Glib.Signal_NameTo API doc
To spec := "remove";

   procedure On_RemoveTo API doc
To body

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

       Call  : Cb_Gtk_Container_Gtk_Widget_VoidTo API doc
To spec;

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

   procedure On_RemoveTo API doc
To body

      (Self  : not null access Gtk_Container_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); 
```
```
 
```

   Signal_Set_Focus_Child : constant Glib.Signal_NameTo API doc
To spec := "set-focus-child";

   procedure On_Set_Focus_ChildTo API doc
To body

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

       Call  : Cb_Gtk_Container_Gtk_Widget_VoidTo API doc
To spec;

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

   procedure On_Set_Focus_ChildTo API doc
To body

      (Self  : not null access Gtk_Container_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); 
```
```
 
```
```
   ---------------- 
```
```
   -- 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_Container_RecordTo API doc
To spec, Gtk_ContainerTo API doc
To spec);

```
   function "+" 
```

     (Widget : access Gtk_Container_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_ContainerTo API doc
To spec

   renames Implements_Gtk_Buildable.To_ObjectTo API doc
To spec
To body;

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

   Resize_Mode_PropertyTo API doc
To spec : constant Gtk.Enums.Property_Gtk_Resize_ModeTo API doc
To spec :=

     Gtk.Enums.BuildTo API doc
To spec
To body ("resize-mode");

   Child_PropertyTo API doc
To spec : constant Glib.Properties.Property_ObjectTo API doc
To spec :=

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

   Border_Width_PropertyTo API doc
To spec : constant Glib.Properties.Property_UintTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("border-width");

end Gtk.ContainerTo API doc
To spec
To body;

Documentation