File: gtk-cell_layout.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> 
```

--  Gtk.Cell_Layout.Gtk_Cell_Layout is an interface to be implemented by all

```
--  objects which want to provide a 
```

--  Gtk.Tree_View_Column.Gtk_Tree_View_Column<!-- -->-like API for packing

--  cells, setting attributes and data funcs.

```
-- 
```

--  One of the notable features provided by implementations of GtkCellLayout

--  are *attributes*. Attributes let you set the properties in flexible ways.

--  They can just be set to constant values like regular properties. But they

--  can also be mapped to a column of the underlying tree model with

--  gtk_cell_layout_set_attributes, which means that the value of the attribute

--  can change from cell to cell as they are rendered by the cell renderer.

--  Finally, it is possible to specify a function with

--  Gtk.Cell_Layout.Set_Cell_Data_Func that is called to determine the value of

--  the attribute for each cell that is rendered.

```
-- 
```

--  == GtkCellLayouts as GtkBuildable ==

```
-- 
```

--  Implementations of GtkCellLayout which also implement the GtkBuildable

--  interface (Gtk.Cell_View.Gtk_Cell_View, Gtk.Icon_View.Gtk_Icon_View,

--  Gtk.Combo_Box.Gtk_Combo_Box, Gtk.Entry_Completion.Gtk_Entry_Completion,

--  Gtk.Tree_View_Column.Gtk_Tree_View_Column) accept GtkCellRenderer objects

--  as <child> elements in UI definitions. They support a custom <attributes>

--  element for their children, which can contain multiple <attribute>

--  elements. Each <attribute> element has a name attribute which specifies a

--  property of the cell renderer; the content of the element is the attribute

```
--  value. 
```
```
-- 
```

--  == A UI definition fragment specifying attributes ==

```
-- 
```
```
--    <object class="GtkCellView"> 
```
```
--    <child> 
```

--    <object class="GtkCellRendererText"/>

```
--    <attributes> 
```

--    <attribute name="text">0</attribute>

```
--    </attributes> 
```
```
--    </child>" 
```
```
--    </object> 
```

--  Furthermore for implementations of GtkCellLayout that use a

--  Gtk.Cell_Area.Gtk_Cell_Area to lay out cells (all GtkCellLayouts in GTK+

--  use a GtkCellArea) <link linkend="cell-properties">cell properties</link>

--  can also be defined in the format by specifying the custom <cell-packing>

--  attribute which can contain multiple <property> elements defined in the

```
--  normal way. 
```
```
-- 
```

--  == A UI definition fragment specifying cell properties ==

```
-- 
```

--    <object class="GtkTreeViewColumn">

```
--    <child> 
```

--    <object class="GtkCellRendererText"/>

```
--    <cell-packing> 
```

--    <property name="align">True</property>

--    <property name="expand">False</property>

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

--  == Subclassing GtkCellLayout implementations ==

```
-- 
```

--  When subclassing a widget that implements Gtk.Cell_Layout.Gtk_Cell_Layout

--  like Gtk.Icon_View.Gtk_Icon_View or Gtk.Combo_Box.Gtk_Combo_Box, there are

--  some considerations related to the fact that these widgets internally use a

--  Gtk.Cell_Area.Gtk_Cell_Area. The cell area is exposed as a construct-only

--  property by these widgets. This means that it is possible to e.g. do

```
-- 
```

--    combo = g_object_new (GTK_TYPE_COMBO_BOX, "cell-area", my_cell_area, NULL);

```
-- 
```

--  to use a custom cell area with a combo box. But construct properties are

--  only initialized *after* instance init functions have run, which means that

--  using functions which rely on the existence of the cell area in your

--  subclass' init function will cause the default cell area to be

--  instantiated. In this case, a provided construct property value will be

--  ignored (with a warning, to alert you to the problem).

```
-- 
```
```
--    static void 
```

--    my_combo_box_init (MyComboBox *b)

```
--    { 
```
```
--       GtkCellRenderer *cell; 
```

--       cell = gtk_cell_renderer_pixbuf_new ();

--       /* The following call causes the default cell area for combo boxes,

--       * a GtkCellAreaBox, to be instantiated

```
--       */ 
```

--       gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (b), cell, FALSE);

```
--       ... 
```
```
--    } 
```
```
--    GtkWidget * 
```

--    my_combo_box_new (GtkCellArea *area)

```
--    { 
```

--       /* This call is going to cause a warning

```
--       * about area being ignored 
```
```
--       */ 
```

--       return g_object_new (MY_TYPE_COMBO_BOX, "cell-area", area, NULL);

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

--  If supporting alternative cell areas with your derived widget is not

--  important, then this does not have to concern you. If you want to support

--  alternative cell areas, you can do so by moving the problematic calls out

--  of init and into a constructor for your class.

```
-- 
```
```
-- 
```
```
--  </description> 
```
```
--  <group>Trees and Lists</group> 
```

--  <testgtk>create_cell_view.adb</testgtk>

```
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.ObjectTo API doc
To spec
To body;       use Glib.ObjectTo 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.Cell_RendererTo API doc
To spec
To body; use Gtk.Cell_RendererTo API doc
To spec
To body;

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

```
 
```

package Gtk.Cell_LayoutTo API doc
To spec
To body is

```
 
```

   type Gtk_Cell_Layout is new Glib.Types.GType_InterfaceTo API doc
To spec;

   Null_Gtk_Cell_Layout : constant Gtk_Cell_LayoutTo API doc
To spec;

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

   type Gtk_Cell_Layout_Data_Func is access procedure

     (Cell_Layout : Gtk_Cell_LayoutTo API doc
To spec;

      Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API doc
To spec'Class;

      Tree_Model  : Gtk.Tree_Model.Gtk_Tree_ModelTo API doc
To spec;

      Iter        : Gtk.Tree_Model.Gtk_Tree_IterTo API doc
To spec
To body);

   --  A function which should set the value of Cell_Layout's cell renderer(s)

```
   --  as appropriate. 
```

   --  "cell_layout": a Gtk.Cell_Layout.Gtk_Cell_Layout

   --  "cell": the cell renderer whose value is to be set

```
   --  "tree_model": the model 
```

   --  "iter": a Gtk.Tree_Model.Gtk_Tree_Iter indicating the row to set the

```
   --  value for 
```
```
 
```
```
   ------------------ 
```
```
   -- 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_cell_layout_get_type");

```
 
```
```
   ------------- 
```
```
   -- Methods -- 
```
```
   ------------- 
```
```
 
```

   procedure Add_AttributeTo API doc
To body

      (Cell_Layout : Gtk_Cell_LayoutTo API doc
To spec;

       Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API doc
To spec'Class;

       Attribute   : UTF8_StringTo API doc
To spec;

       Column      : GintTo API doc
To spec);

   --  Adds an attribute mapping to the list in Cell_Layout.

   --  The Column is the column of the model to get a value from, and the

   --  Attribute is the parameter on Cell to be set from the value. So for

   --  example if column 2 of the model contains strings, you could have the

   --  "text" attribute of a Gtk.Cell_Renderer_Text.Gtk_Cell_Renderer_Text get

```
   --  its values from column 2. 
```
```
   --  Since: gtk+ 2.4 
```

   --  "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer

   --  "attribute": an attribute on the renderer

   --  "column": the column position on the model to get the attribute from

```
 
```

   procedure ClearTo API doc
To body (Cell_Layout : Gtk_Cell_LayoutTo API doc
To spec);

   pragma Import (C, ClearTo API doc
To spec, "gtk_cell_layout_clear");

   --  Unsets all the mappings on all renderers on Cell_Layout and removes all

```
   --  renderers from Cell_Layout. 
```
```
   --  Since: gtk+ 2.4 
```
```
 
```

   procedure Clear_AttributesTo API doc
To body

      (Cell_Layout : Gtk_Cell_LayoutTo API doc
To spec;

       Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API doc
To spec'Class);

   --  Clears all existing attributes previously set with

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

   --  "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer to clear the attribute

```
   --  mapping on 
```
```
 
```
```
   function Get_CellsTo API doc
To body 
```

      (Cell_Layout : Gtk_Cell_LayoutTo API doc
To spec)

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

   --  Returns the cell renderers which have been added to Cell_Layout.

```
   --  Since: gtk+ 2.12 
```
```
 
```
```
   procedure Pack_EndTo API doc
To body 
```

      (Cell_Layout : Gtk_Cell_LayoutTo API doc
To spec;

       Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API doc
To spec'Class;

```
       Expand      : Boolean); 
```

   --  Adds the Cell to the end of Cell_Layout. If Expand is False, then the

   --  Cell is allocated no more space than it needs. Any unused space is

   --  divided evenly between cells for which Expand is True.

   --  Note that reusing the same cell renderer is not supported.

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

   --  "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer

   --  "expand": True if Cell is to be given extra space allocated to

```
   --  Cell_Layout 
```
```
 
```

   procedure Pack_StartTo API doc
To body

      (Cell_Layout : Gtk_Cell_LayoutTo API doc
To spec;

       Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API doc
To spec'Class;

```
       Expand      : Boolean); 
```

   --  Packs the Cell into the beginning of Cell_Layout. If Expand is False,

   --  then the Cell is allocated no more space than it needs. Any unused space

   --  is divided evenly between cells for which Expand is True.

   --  Note that reusing the same cell renderer is not supported.

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

   --  "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer

   --  "expand": True if Cell is to be given extra space allocated to

```
   --  Cell_Layout 
```
```
 
```
```
   procedure ReorderTo API doc
To body 
```

      (Cell_Layout : Gtk_Cell_LayoutTo API doc
To spec;

       Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API doc
To spec'Class;

       Position    : GintTo API doc
To spec);

```
   --  Re-inserts Cell at Position. 
```

   --  Note that Cell has already to be packed into Cell_Layout for this to

```
   --  function properly. 
```
```
   --  Since: gtk+ 2.4 
```

   --  "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer to reorder

   --  "position": new position to insert Cell at

```
 
```

   procedure Set_Cell_Data_FuncTo API doc
To body

      (Cell_Layout : Gtk_Cell_LayoutTo API doc
To spec;

       Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API doc
To spec'Class;

       Func        : Gtk_Cell_Layout_Data_FuncTo API doc
To spec);

   --  Sets the Gtk_Cell_Layout_Data_Func to use for Cell_Layout.

   --  This function is used instead of the standard attributes mapping for

   --  setting the column value, and should set the value of Cell_Layout's cell

```
   --  renderer(s) as appropriate. 
```

   --  Func may be null to remove a previously set function.

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

   --  "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer

   --  "func": the Gtk_Cell_Layout_Data_Func to use, or null

```
 
```
```
   generic 
```

      type User_Data_Type (<>) is private;

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

   package Set_Cell_Data_Func_User_DataTo API doc
To body is

```
 
```

      type Gtk_Cell_Layout_Data_Func is access procedure

        (Cell_Layout : Gtk.Cell_Layout.Gtk_Cell_LayoutTo API doc
To spec;

         Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API doc
To spec'Class;

         Tree_Model  : Gtk.Tree_Model.Gtk_Tree_ModelTo API doc
To spec;

         Iter        : Gtk.Tree_Model.Gtk_Tree_IterTo API doc
To spec
To body;

         Data        : User_Data_TypeTo API doc
To spec);

      --  A function which should set the value of Cell_Layout's cell renderer(s)

```
      --  as appropriate. 
```

      --  "cell_layout": a Gtk.Cell_Layout.Gtk_Cell_Layout

      --  "cell": the cell renderer whose value is to be set

```
      --  "tree_model": the model 
```

      --  "iter": a Gtk.Tree_Model.Gtk_Tree_Iter indicating the row to set the

```
      --  value for 
```

      --  "data": user data passed to Gtk.Cell_Layout.Set_Cell_Data_Func

```
 
```

      procedure Set_Cell_Data_FuncTo API doc
To body

         (Cell_Layout : Gtk.Cell_Layout.Gtk_Cell_LayoutTo API doc
To spec;

          Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API doc
To spec'Class;

          Func        : Gtk_Cell_Layout_Data_FuncTo API doc
To spec;

          Func_Data   : User_Data_TypeTo API doc
To spec);

      --  Sets the Gtk_Cell_Layout_Data_Func to use for Cell_Layout.

      --  This function is used instead of the standard attributes mapping for

      --  setting the column value, and should set the value of Cell_Layout's

      --  cell renderer(s) as appropriate.

      --  Func may be null to remove a previously set function.

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

      --  "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer

      --  "func": the Gtk_Cell_Layout_Data_Func to use, or null

      --  "func_data": user data for Func

```
 
```

   end Set_Cell_Data_Func_User_DataTo API doc
To spec
To body;

```
 
```
```
   ---------------- 
```
```
   -- Interfaces -- 
```
```
   ---------------- 
```

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

```
   -- 
```
```
   --  - "Gtk_Cell_Layout" 
```
```
 
```

   function "+"To API doc
To body (W : Gtk_Cell_LayoutTo API doc
To spec) return Gtk_Cell_LayoutTo API doc
To spec;

```
   pragma Inline ("+"); 
```
```
 
```
```
private 
```
```
 
```

Null_Gtk_Cell_LayoutTo API doc
To spec : constant Gtk_Cell_LayoutTo API doc
To spec :=

   Gtk_Cell_LayoutTo API doc
To spec (Glib.Types.Null_InterfaceTo API doc
To spec);

end Gtk.Cell_LayoutTo API doc
To spec
To body;

Documentation