Index

Package: Cell_Area

Description

package Gtk.Cell_Area is

The Gtk.Cell_Area.Gtk_Cell_Area is an abstract class for Gtk.Cell_Layout.Gtk_Cell_Layout widgets (also referred to as "layouting widgets") to interface with an arbitrary number of Gtk_Cell_Renderers and interact with the user for a given Gtk.Tree_Model.Gtk_Tree_Model row.

The cell area handles events, focus navigation, drawing and size requests and allocations for a given row of data.

Usually users dont have to interact with the Gtk.Cell_Area.Gtk_Cell_Area directly unless they are implementing a cell-layouting widget themselves. == Requesting area sizes == As outlined in <link linkend="geometry-management">GtkWidget's geometry management section</link>, GTK+ uses a height-for-width geometry management system to compute the sizes of widgets and user interfaces.

Gtk.Cell_Area.Gtk_Cell_Area uses the same semantics to calculate the size of an area for an arbitrary number of Gtk.Tree_Model.Gtk_Tree_Model rows.

When requesting the size of a cell area one needs to calculate the size for a handful of rows, and this will be done differently by different layouting widgets. For instance a Gtk.Tree_View_Column.Gtk_Tree_View_Column always lines up the areas from top to bottom while a Gtk.Icon_View.Gtk_Icon_View on the other hand might enforce that all areas received the same width and wrap the areas around, requesting height for more cell areas when allocated less width.

It's also important for areas to maintain some cell alignments with areas rendered for adjacent rows (cells can appear "columnized" inside an area even when the size of cells are different in each row). For this reason the Gtk.Cell_Area.Gtk_Cell_Area uses a Gtk.Cell_Area_Context.Gtk_Cell_Area_Context object to store the alignments and sizes along the way (as well as the overall largest minimum and natural size for all the rows which have been calculated with the said context).

The Gtk.Cell_Area_Context.Gtk_Cell_Area_Context is an opaque object specific to the Gtk.Cell_Area.Gtk_Cell_Area which created it (see Gtk.Cell_Area.Create_Context). The owning cell-layouting widget can create as many contexts as it wishes to calculate sizes of rows which should receive the same size in at least one orientation (horizontally or vertically), However, it's important that the same Gtk.Cell_Area_Context.Gtk_Cell_Area_Context which was used to request the sizes for a given Gtk.Tree_Model.Gtk_Tree_Model row be used when rendering or processing events for that row.

In order to request the width of all the rows at the root level of a Gtk.Tree_Model.Gtk_Tree_Model one would do the following: == Requesting the width of a handful of GtkTreeModel rows == GtkTreeIter iter; gint minimum_width; gint natural_width; valid = gtk_tree_model_get_iter_first (model, &iter); while (valid) { gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL); valid = gtk_tree_model_iter_next (model, &iter); } gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width); Note that in this example it's not important to observe the returned minimum and natural width of the area for each row unless the cell-layouting object is actually interested in the widths of individual rows. The overall width is however stored in the accompanying Gtk.Cell_Area_Context.Gtk_Cell_Area_Context object and can be consulted at any time.

This can be useful since Gtk.Cell_Layout.Gtk_Cell_Layout widgets usually have to support requesting and rendering rows in treemodels with an exceedingly large amount of rows. The Gtk.Cell_Layout.Gtk_Cell_Layout widget in that case would calculate the required width of the rows in an idle or timeout source (see g_timeout_add) and when the widget is requested its actual width in Gtk.Widget.GObject_Class.get_preferred_width it can simply consult the width accumulated so far in the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context object.

A simple example where rows are rendered from top to bottom and take up the full width of the layouting widget would look like: == A typical get_preferred_width implementation == static void foo_get_preferred_width (GtkWidget *widget, gint *minimum_size, gint *natural_size) { Foo *foo = FOO (widget); FooPrivate *priv = foo->priv; foo_ensure_at_least_one_handfull_of_rows_have_been_requested (foo); gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size); } In the above example the Foo widget has to make sure that some row sizes have been calculated (the amount of rows that Foo judged was appropriate to request space for in a single timeout iteration) before simply returning the amount of space required by the area via the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context.

Requesting the height for width (or width for height) of an area is a similar task except in this case the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context does not store the data (actually, it does not know how much space the layouting widget plans to allocate it for every row. It's up to the layouting widget to render each row of data with the appropriate height and width which was requested by the Gtk.Cell_Area.Gtk_Cell_Area).

In order to request the height for width of all the rows at the root level of a Gtk.Tree_Model.Gtk_Tree_Model one would do the following: == Requesting the height for width of a handful of GtkTreeModel rows == GtkTreeIter iter; gint minimum_height; gint natural_height; gint full_minimum_height = 0; gint full_natural_height = 0; valid = gtk_tree_model_get_iter_first (model, &iter); while (valid) { gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); gtk_cell_area_get_preferred_height_for_width (area, context, widget, width, &minimum_height, &natural_height); if (width_is_for_allocation) cache_row_height (&iter, minimum_height, natural_height); full_minimum_height += minimum_height; full_natural_height += natural_height; valid = gtk_tree_model_iter_next (model, &iter); } Note that in the above example we would need to cache the heights returned for each row so that we would know what sizes to render the areas for each row. However we would only want to really cache the heights if the request is intended for the layouting widgets real allocation.

In some cases the layouting widget is requested the height for an arbitrary for_width, this is a special case for layouting widgets who need to request size for tens of thousands of rows. For this case it's only important that the layouting widget calculate one reasonably sized chunk of rows and return that height synchronously. The reasoning here is that any layouting widget is at least capable of synchronously calculating enough height to fill the screen height (or scrolled window height) in response to a single call to Gtk.Widget.GObject_Class.get_preferred_height_for_width.

Returning a perfect height for width that is larger than the screen area is inconsequential since after the layouting receives an allocation from a scrolled window it simply continues to drive the scrollbar values while more and more height is required for the row heights that are calculated in the background. == Rendering Areas == Once area sizes have been aquired at least for the rows in the visible area of the layouting widget they can be rendered at Gtk.Widget.GObject_Class.draw time.

A crude example of how to render all the rows at the root level runs as follows: == Requesting the width of a handful of GtkTreeModel rows == GtkAllocation allocation; GdkRectangle cell_area = { 0, }; GtkTreeIter iter; gint minimum_width; gint natural_width; gtk_widget_get_allocation (widget, &allocation); cell_area.width = allocation.width; valid = gtk_tree_model_get_iter_first (model, &iter); while (valid) { cell_area.height = get_cached_height_for_row (&iter); gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); gtk_cell_area_render (area, context, widget, cr, &cell_area, &cell_area, state_flags, FALSE); cell_area.y += cell_area.height; valid = gtk_tree_model_iter_next (model, &iter); } Note that the cached height in this example really depends on how the layouting widget works. The layouting widget might decide to give every row its minimum or natural height or, if the model content is expected to fit inside the layouting widget without scrolling, it would make sense to calculate the allocation for each row at Gtk.Widget.Gtk_Widget::size-allocate time using gtk_distribute_natural_allocation. == Handling Events and Driving Keyboard Focus == Passing events to the area is as simple as handling events on any normal widget and then passing them to the Gtk.Cell_Area.Event API as they come in. Usually Gtk.Cell_Area.Gtk_Cell_Area is only interested in button events, however some customized derived areas can be implemented who are interested in handling other events. Handling an event can trigger the Gtk.Cell_Area.Gtk_Cell_Area::focus-changed signal to fire; as well as Gtk.Cell_Area.Gtk_Cell_Area::add-editable in the case that an editable cell was clicked and needs to start editing. You can call Gtk.Cell_Area.Stop_Editing at any time to cancel any cell editing that is currently in progress.

The Gtk.Cell_Area.Gtk_Cell_Area drives keyboard focus from cell to cell in a way similar to Gtk.Widget.Gtk_Widget. For layouting widgets that support giving focus to cells it's important to remember to pass Gtk.Cell_Renderer.Cell_Renderer_Focused to the area functions for the row that has focus and to tell the area to paint the focus at render time.

Layouting widgets that accept focus on cells should implement the Gtk.Widget.GObject_Class.focus virtual method. The layouting widget is always responsible for knowing where Gtk.Tree_Model.Gtk_Tree_Model rows are rendered inside the widget, so at Gtk.Widget.GObject_Class.focus time the layouting widget should use the Gtk.Cell_Area.Gtk_Cell_Area methods to navigate focus inside the area and then observe the GtkDirectionType to pass the focus to adjacent rows and areas.

A basic example of how the Gtk.Widget.GObject_Class.focus virtual method should be implemented: == Implementing keyboard focus navigation == static gboolean foo_focus (GtkWidget *widget, GtkDirectionType direction) { Foo *foo = FOO (widget); FooPrivate *priv = foo->priv; gint focus_row; gboolean have_focus = FALSE; focus_row = priv->focus_row; if (!gtk_widget_has_focus (widget)) gtk_widget_grab_focus (widget); valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row); while (valid) { gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE); if (gtk_cell_area_focus (priv->area, direction)) { priv->focus_row = focus_row; have_focus = TRUE; break; } else { if (direction == GTK_DIR_RIGHT || direction == GTK_DIR_LEFT) break; else if (direction == GTK_DIR_UP || direction == GTK_DIR_TAB_BACKWARD) { if (focus_row == 0) break; else { focus_row--; valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row); } } else { if (focus_row == last_row) break; else { focus_row++; valid = gtk_tree_model_iter_next (priv->model, &iter); } } } } return have_focus; } Note that the layouting widget is responsible for matching the GtkDirectionType values to the way it lays out its cells. == Cell Properties == The Gtk.Cell_Area.Gtk_Cell_Area introduces *cell properties* for Gtk_Cell_Renderers in very much the same way that Gtk.Container.Gtk_Container introduces <link linkend="child-properties">child properties</link> for Gtk_Widgets. This provides some general interfaces for defining the relationship cell areas have with their cells. For instance in a Gtk.Cell_Area_Box.Gtk_Cell_Area_Box a cell might "expand" and receive extra space when the area is allocated more than its full natural request, or a cell might be configured to "align" with adjacent rows which were requested and rendered with the same Gtk.Cell_Area_Context.Gtk_Cell_Area_Context.

Use gtk_cell_area_class_install_cell_property to install cell properties for a cell area class and gtk_cell_area_class_find_cell_property or gtk_cell_area_class_list_cell_properties to get information about existing cell properties.

To set the value of a cell property, use Gtk.Cell_Area.Cell_Set_Property, gtk_cell_area_cell_set or gtk_cell_area_cell_set_valist. To obtain the value of a cell property, use Gtk.Cell_Area.Cell_Get_Property, gtk_cell_area_cell_get or gtk_cell_area_cell_get_valist.

Packages

Foreach_User_Data (generic)

Foreach_Alloc_User_Data (generic)

Set_Cell_Data_Func_User_Data (generic)

Implements_Gtk_Buildable (new Glib.Types.Implements)

Implements_Gtk_Cell_Layout (new Glib.Types.Implements)

Classes

Gtk_Cell_Area_Record

type Gtk_Cell_Area_Record is new GObject_Record with null record;

Ancestors:

Immediate Children:

Primitive operations:

Activate_Cell
Add_Attribute
Add_Focus_Sibling
Apply_Attributes
Attribute_Connect
Attribute_Disconnect
Cell_Get_Property
Cell_Set_Property
Clear_Attributes
Copy_Context
Create_Context
Foreach_Alloc
Get_Cell_Allocation
Get_Cell_At_Position
Get_Current_Path_String
Get_Edit_Widget
Get_Edited_Cell
Get_Focus_Cell
Get_Focus_From_Sibling
Get_Focus_Siblings
Get_Preferred_Height
Get_Preferred_Height_For_Width
Get_Preferred_Width
Get_Preferred_Width_For_Height
Get_Request_Mode
Glib.Object.Deallocate (Inherited)
Glib.Object.Get_Type (Inherited)
Glib.Object.Notify (Inherited)
Glib.Object.Ref (Inherited)
Glib.Object.Ref_Sink (Inherited)
Glib.Object.Unref (Inherited)
Has_Renderer
Inner_Cell_Area
Is_Activatable
Is_Focus_Sibling
On_Add_Editable
On_Add_Editable
On_Apply_Attributes
On_Apply_Attributes
On_Focus_Changed
On_Focus_Changed
On_Remove_Editable
On_Remove_Editable
Remove_Focus_Sibling
Request_Renderer
Set_Cell_Data_Func
Set_Focus_Cell
Stop_Editing

Types

Gtk_Cell_Area

type Gtk_Cell_Area is access all Gtk_Cell_Area_Record'Class;

Gtk_Cell_Callback

type Gtk_Cell_Callback is access function
     (Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class)
   return Boolean;
The type of the callback functions used for iterating over the cell renderers of a Gtk.Cell_Area.Gtk_Cell_Area, see Gtk.Cell_Area.Foreach. "renderer": the cell renderer to operate on

Gtk_Cell_Alloc_Callback

type Gtk_Cell_Alloc_Callback is access function
     (Renderer        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
      Cell_Area       : Gdk.Rectangle.Gdk_Rectangle;
      Cell_Background : Gdk.Rectangle.Gdk_Rectangle) return Boolean;
The type of the callback functions used for iterating over the cell renderers and their allocated areas inside a Gtk.Cell_Area.Gtk_Cell_Area, see Gtk.Cell_Area.Foreach_Alloc. "renderer": the cell renderer to operate on "cell_area": the area allocated to Renderer inside the rectangle provided to Gtk.Cell_Area.Foreach_Alloc. "cell_background": the background area for Renderer inside the background area provided to Gtk.Cell_Area.Foreach_Alloc.

Gtk_Cell_Layout_Data_Func

type Gtk_Cell_Layout_Data_Func is access procedure
     (Cell_Layout : Gtk.Cell_Layout.Gtk_Cell_Layout;
      Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
      Tree_Model  : Gtk.Tree_Model.Gtk_Tree_Model;
      Iter        : Gtk.Tree_Model.Gtk_Tree_Iter);
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

Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_Gtk_Cell_Editable_Cairo_Rectangle_Int_UTF8_String_Void

type Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_Gtk_Cell_Editable_Cairo_Rectangle_Int_UTF8_String_Void is not null access procedure
     (Self      : access Gtk_Cell_Area_Record'Class;
      Renderer  : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
      Editable  : Gtk.Cell_Editable.Gtk_Cell_Editable;
      Cell_Area : Cairo.Region.Cairo_Rectangle_Int;
      Path      : UTF8_String);

Cb_GObject_Gtk_Cell_Renderer_Gtk_Cell_Editable_Cairo_Rectangle_Int_UTF8_String_Void

type Cb_GObject_Gtk_Cell_Renderer_Gtk_Cell_Editable_Cairo_Rectangle_Int_UTF8_String_Void is not null access procedure
     (Self      : access Glib.Object.GObject_Record'Class;
      Renderer  : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
      Editable  : Gtk.Cell_Editable.Gtk_Cell_Editable;
      Cell_Area : Cairo.Region.Cairo_Rectangle_Int;
      Path      : UTF8_String);

Cb_Gtk_Cell_Area_Gtk_Tree_Model_Gtk_Tree_Iter_Boolean_Boolean_Void

type Cb_Gtk_Cell_Area_Gtk_Tree_Model_Gtk_Tree_Iter_Boolean_Boolean_Void is not null access procedure
     (Self        : access Gtk_Cell_Area_Record'Class;
      Model       : Gtk.Tree_Model.Gtk_Tree_Model;
      Iter        : Gtk.Tree_Model.Gtk_Tree_Iter;
      Is_Expander : Boolean;
      Is_Expanded : Boolean);

Cb_GObject_Gtk_Tree_Model_Gtk_Tree_Iter_Boolean_Boolean_Void

type Cb_GObject_Gtk_Tree_Model_Gtk_Tree_Iter_Boolean_Boolean_Void is not null access procedure
     (Self        : access Glib.Object.GObject_Record'Class;
      Model       : Gtk.Tree_Model.Gtk_Tree_Model;
      Iter        : Gtk.Tree_Model.Gtk_Tree_Iter;
      Is_Expander : Boolean;
      Is_Expanded : Boolean);

Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_UTF8_String_Void

type Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_UTF8_String_Void is not null access procedure
     (Self     : access Gtk_Cell_Area_Record'Class;
      Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
      Path     : UTF8_String);

Cb_GObject_Gtk_Cell_Renderer_UTF8_String_Void

type Cb_GObject_Gtk_Cell_Renderer_UTF8_String_Void is not null access procedure
     (Self     : access Glib.Object.GObject_Record'Class;
      Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
      Path     : UTF8_String);

Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_Gtk_Cell_Editable_Void

type Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_Gtk_Cell_Editable_Void is not null access procedure
     (Self     : access Gtk_Cell_Area_Record'Class;
      Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
      Editable : Gtk.Cell_Editable.Gtk_Cell_Editable);

Cb_GObject_Gtk_Cell_Renderer_Gtk_Cell_Editable_Void

type Cb_GObject_Gtk_Cell_Renderer_Gtk_Cell_Editable_Void is not null access procedure
     (Self     : access Glib.Object.GObject_Record'Class;
      Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
      Editable : Gtk.Cell_Editable.Gtk_Cell_Editable);

Constants & Global variables

Edit_Widget_Property (Glib.Properties.Property_Interface)

Edit_Widget_Property : constant Glib.Properties.Property_Interface;
Type: Gtk.Cell_Editable.Gtk_Cell_Editable The widget currently editing the edited cell This property is read-only and only changes as a result of a call Gtk.Cell_Area.Activate_Cell.

Edited_Cell_Property (Glib.Properties.Property_Object)

Edited_Cell_Property : constant Glib.Properties.Property_Object;
Type: Gtk.Cell_Renderer.Gtk_Cell_Renderer The cell in the area that is currently edited This property is read-only and only changes as a result of a call Gtk.Cell_Area.Activate_Cell.

Focus_Cell_Property (Glib.Properties.Property_Object)

Focus_Cell_Property : constant Glib.Properties.Property_Object;
Type: Gtk.Cell_Renderer.Gtk_Cell_Renderer The cell in the area that currently has focus

Signal_Add_Editable (Glib.Signal_Name)

Signal_Add_Editable : constant Glib.Signal_Name := "add-editable";

Signal_Apply_Attributes (Glib.Signal_Name)

Signal_Apply_Attributes : constant Glib.Signal_Name := "apply-attributes";

Signal_Focus_Changed (Glib.Signal_Name)

Signal_Focus_Changed : constant Glib.Signal_Name := "focus-changed";

Signal_Remove_Editable (Glib.Signal_Name)

Signal_Remove_Editable : constant Glib.Signal_Name := "remove-editable";

Subprograms & Entries

Get_Type

function Get_Type return Glib.GType;

Activate

function Activate 
(Self: not null access Gtk_Cell_Area_Record;
Context: not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class;
Widget: not null access Gtk.Widget.Gtk_Widget_Record'Class;
Cell_Area: Gdk.Rectangle.Gdk_Rectangle;
Flags: Gtk.Cell_Renderer.Gtk_Cell_Renderer_State;
Edit_Only: Boolean) return Boolean;
Activates Area, usually by activating the currently focused cell, however some subclasses which embed widgets in the area can also activate a widget if it currently has the focus. Since: gtk+ 3.0 "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context in context with the current row data "widget": the Gtk.Widget.Gtk_Widget that Area is rendering on "cell_area": the size and location of Area relative to Widget's allocation "flags": the Gtk.Cell_Renderer.Gtk_Cell_Renderer_State flags for Area for this row of data. "edit_only": if True then only cell renderers that are Gtk.Cell_Renderer.Cell_Renderer_Mode_Editable will be activated.

Activate_Cell

function Activate_Cell 
(Self: not null access Gtk_Cell_Area_Record;
Widget: not null access Gtk.Widget.Gtk_Widget_Record'Class;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Event: Gdk.Event.Gdk_Event;
Cell_Area: Gdk.Rectangle.Gdk_Rectangle;
Flags: Gtk.Cell_Renderer.Gtk_Cell_Renderer_State) return Boolean;
This is used by Gtk.Cell_Area.Gtk_Cell_Area subclasses when handling events to activate cells, the base Gtk.Cell_Area.Gtk_Cell_Area class activates cells for keyboard events for free in its own GtkCellArea->activate implementation. Since: gtk+ 3.0 "widget": the Gtk.Widget.Gtk_Widget that Area is rendering onto "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer in Area to activate "event": the Gdk.Event.Gdk_Event for which cell activation should occur "cell_area": the Gdk.Rectangle.Gdk_Rectangle in Widget relative coordinates of Renderer for the current row. "flags": the Gtk.Cell_Renderer.Gtk_Cell_Renderer_State for Renderer

Add

procedure Add 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class);
Adds Renderer to Area with the default child cell properties. Since: gtk+ 3.0 "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to add to Area

Add_Focus_Sibling

procedure Add_Focus_Sibling 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Sibling: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class);
Adds Sibling to Renderer's focusable area, focus will be drawn around Renderer and all of its siblings if Renderer can focus for a given row. Events handled by focus siblings can also activate the given focusable Renderer. Since: gtk+ 3.0 "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer expected to have focus "sibling": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to add to Renderer's focus area

Apply_Attributes

procedure Apply_Attributes 
(Self: not null access Gtk_Cell_Area_Record;
Tree_Model: Gtk.Tree_Model.Gtk_Tree_Model;
Iter: Gtk.Tree_Model.Gtk_Tree_Iter;
Is_Expander: Boolean;
Is_Expanded: Boolean);
Applies any connected attributes to the renderers in Area by pulling the values from Tree_Model. Since: gtk+ 3.0 "tree_model": the Gtk.Tree_Model.Gtk_Tree_Model to pull values from "iter": the Gtk.Tree_Model.Gtk_Tree_Iter in Tree_Model to apply values for "is_expander": whether Iter has children "is_expanded": whether Iter is expanded in the view and children are visible

Attribute_Connect

procedure Attribute_Connect 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Attribute: UTF8_String;
Column: Gint);
Connects an Attribute to apply values from Column for the Gtk.Tree_Model.Gtk_Tree_Model in use. Since: gtk+ 3.0 "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to connect an attribute for "attribute": the attribute name "column": the Gtk.Tree_Model.Gtk_Tree_Model column to fetch attribute values from

Attribute_Disconnect

procedure Attribute_Disconnect 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Attribute: UTF8_String);
Disconnects Attribute for the Renderer in Area so that attribute will no longer be updated with values from the model. Since: gtk+ 3.0 "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to disconnect an attribute for "attribute": the attribute name

Cell_Get_Property

procedure Cell_Get_Property 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Property_Name: UTF8_String;
Value: in out Glib.Values.GValue);
Gets the value of a cell property for Renderer in Area. Since: gtk+ 3.0 "renderer": a Gtk.Cell_Renderer.Gtk_Cell_Renderer inside Area "property_name": the name of the property to get "value": a location to return the value

Cell_Set_Property

procedure Cell_Set_Property 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Property_Name: UTF8_String;
Value: in out Glib.Values.GValue);
Sets a cell property for Renderer in Area. Since: gtk+ 3.0 "renderer": a Gtk.Cell_Renderer.Gtk_Cell_Renderer inside Area "property_name": the name of the cell property to set "value": the value to set the cell property to

Copy_Context

function Copy_Context 
(Self: not null access Gtk_Cell_Area_Record;
Context: not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class) return Gtk.Cell_Area_Context.Gtk_Cell_Area_Context;
This is sometimes needed for cases where rows need to share alignments in one orientation but may be separately grouped in the opposing orientation. For instance, Gtk.Icon_View.Gtk_Icon_View creates all icons (rows) to have the same width and the cells theirin to have the same horizontal alignments. However each row of icons may have a separate collective height. Gtk.Icon_View.Gtk_Icon_View uses this to request the heights of each row based on a context which was already used to request all the row widths that are to be displayed. Since: gtk+ 3.0 "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context to copy

Create_Context

function Create_Context 
(Self: not null access Gtk_Cell_Area_Record) return Gtk.Cell_Area_Context.Gtk_Cell_Area_Context;
Creates a Gtk.Cell_Area_Context.Gtk_Cell_Area_Context to be used with Area for all purposes. Gtk.Cell_Area_Context.Gtk_Cell_Area_Context stores geometry information for rows for which it was operated on, it is important to use the same context for the same row of data at all times (i.e. one should render and handle events with the same Gtk.Cell_Area_Context.Gtk_Cell_Area_Context which was used to request the size of those rows of data). Since: gtk+ 3.0

Event

function Event 
(Self: not null access Gtk_Cell_Area_Record;
Context: not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class;
Widget: not null access Gtk.Widget.Gtk_Widget_Record'Class;
Event: Gdk.Event.Gdk_Event;
Cell_Area: Gdk.Rectangle.Gdk_Rectangle;
Flags: Gtk.Cell_Renderer.Gtk_Cell_Renderer_State) return Gint;
Delegates event handling to a Gtk.Cell_Area.Gtk_Cell_Area. Since: gtk+ 3.0 "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context for this row of data. "widget": the Gtk.Widget.Gtk_Widget that Area is rendering to "event": the Gdk.Event.Gdk_Event to handle "cell_area": the Widget relative coordinates for Area "flags": the Gtk.Cell_Renderer.Gtk_Cell_Renderer_State for Area in this row.

Focus

function Focus 
(Self: not null access Gtk_Cell_Area_Record;
Direction: Gtk.Enums.Gtk_Direction_Type) return Boolean;
This should be called by the Area's owning layout widget when focus is to be passed to Area, or moved within Area for a given Direction and row data. Implementing Gtk.Cell_Area.Gtk_Cell_Area classes should implement this method to receive and navigate focus in its own way particular to how it lays out cells. Since: gtk+ 3.0 "direction": the Gtk.Enums.Gtk_Direction_Type

Foreach

procedure Foreach 
(Self: not null access Gtk_Cell_Area_Record;
Callback: Gtk_Cell_Callback);
Calls Callback for every Gtk.Cell_Renderer.Gtk_Cell_Renderer in Area. Since: gtk+ 3.0 "callback": the Gtk_Cell_Callback to call

Foreach_Alloc

procedure Foreach_Alloc 
(Self: not null access Gtk_Cell_Area_Record;
Context: not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class;
Widget: not null access Gtk.Widget.Gtk_Widget_Record'Class;
Cell_Area: Gdk.Rectangle.Gdk_Rectangle;
Background_Area: Gdk.Rectangle.Gdk_Rectangle;
Callback: Gtk_Cell_Alloc_Callback);
Calls Callback for every Gtk.Cell_Renderer.Gtk_Cell_Renderer in Area with the allocated rectangle inside Cell_Area. Since: gtk+ 3.0 "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context for this row of data. "widget": the Gtk.Widget.Gtk_Widget that Area is rendering to "cell_area": the Widget relative coordinates and size for Area "background_area": the Widget relative coordinates of the background area "callback": the Gtk_Cell_Alloc_Callback to call

Get_Cell_Allocation

procedure Get_Cell_Allocation 
(Self: not null access Gtk_Cell_Area_Record;
Context: not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class;
Widget: not null access Gtk.Widget.Gtk_Widget_Record'Class;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Cell_Area: access Gdk.Rectangle.Gdk_Rectangle;
Allocation: access Gdk.Rectangle.Gdk_Rectangle);
Derives the allocation of Renderer inside Area if Area were to be renderered in Cell_Area. Since: gtk+ 3.0 "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context used to hold sizes for Area. "widget": the Gtk.Widget.Gtk_Widget that Area is rendering on "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to get the allocation for "cell_area": the whole allocated area for Area in Widget for this row "allocation": where to store the allocation for Renderer

Get_Current_Path_String

function Get_Current_Path_String 
(Self: not null access Gtk_Cell_Area_Record) return UTF8_String;
Gets the current Gtk.Tree_Model.Gtk_Tree_Path string for the currently applied Gtk.Tree_Model.Gtk_Tree_Iter, this is implicitly updated when Gtk.Cell_Area.Apply_Attributes is called and can be used to interact with renderers from Gtk.Cell_Area.Gtk_Cell_Area subclasses. Since: gtk+ 3.0

Get_Edit_Widget

function Get_Edit_Widget 
(Self: not null access Gtk_Cell_Area_Record) return Gtk.Cell_Editable.Gtk_Cell_Editable;
Gets the Gtk.Cell_Editable.Gtk_Cell_Editable widget currently used to edit the currently edited cell. Since: gtk+ 3.0

Get_Edited_Cell

function Get_Edited_Cell 
(Self: not null access Gtk_Cell_Area_Record) return Gtk.Cell_Renderer.Gtk_Cell_Renderer;
Gets the Gtk.Cell_Renderer.Gtk_Cell_Renderer in Area that is currently being edited. Since: gtk+ 3.0

Get_Focus_Cell

function Get_Focus_Cell 
(Self: not null access Gtk_Cell_Area_Record) return Gtk.Cell_Renderer.Gtk_Cell_Renderer;
Retrieves the currently focused cell for Area Since: gtk+ 3.0

Set_Focus_Cell

procedure Set_Focus_Cell 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class);
Explicitly sets the currently focused cell to Renderer. This is generally called by implementations of Gtk.Cell_Area_Class.Gtk_Cell_Area_Class.focus or Gtk.Cell_Area_Class.Gtk_Cell_Area_Class.event, however it can also be used to implement functions such as Gtk.Tree_View.Set_Cursor_On_Cell. Since: gtk+ 3.0 "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to give focus to

Get_Focus_From_Sibling

function Get_Focus_From_Sibling 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class) return Gtk.Cell_Renderer.Gtk_Cell_Renderer;
Gets the Gtk.Cell_Renderer.Gtk_Cell_Renderer which is expected to be focusable for which Renderer is, or may be a sibling. This is handy for Gtk.Cell_Area.Gtk_Cell_Area subclasses when handling events, after determining the renderer at the event location it can then chose to activate the focus cell for which the event cell may have been a sibling. Since: gtk+ 3.0 "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer

Get_Focus_Siblings

function Get_Focus_Siblings 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class) return Glib.Object.Object_Simple_List.Glist;
Gets the focus sibling cell renderers for Renderer. Since: gtk+ 3.0 "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer expected to have focus

Get_Preferred_Height

procedure Get_Preferred_Height 
(Self: not null access Gtk_Cell_Area_Record;
Context: not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class;
Widget: not null access Gtk.Widget.Gtk_Widget_Record'Class;
Minimum_Height: out Gint;
Natural_Height: out Gint);
Retrieves a cell area's initial minimum and natural height. Area will store some geometrical information in Context along the way; when requesting sizes over an arbitrary number of rows, it's not important to check the Minimum_Height and Natural_Height of this call but rather to consult Gtk.Cell_Area_Context.Get_Preferred_Height after a series of requests. Since: gtk+ 3.0 "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context to perform this request with "widget": the Gtk.Widget.Gtk_Widget where Area will be rendering "minimum_height": location to store the minimum height, or null "natural_height": location to store the natural height, or null

Get_Preferred_Height_For_Width

procedure Get_Preferred_Height_For_Width 
(Self: not null access Gtk_Cell_Area_Record;
Context: not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class;
Widget: not null access Gtk.Widget.Gtk_Widget_Record'Class;
Width: Gint;
Minimum_Height: out Gint;
Natural_Height: out Gint);
Retrieves a cell area's minimum and natural height if it would be given the specified Width. Area stores some geometrical information in Context along the way while calling Gtk.Cell_Area.Get_Preferred_Width. It's important to perform a series of Gtk.Cell_Area.Get_Preferred_Width requests with Context first and then call Gtk.Cell_Area.Get_Preferred_Height_For_Width on each cell area individually to get the height for width of each fully requested row. If at some point, the width of a single row changes, it should be requested with Gtk.Cell_Area.Get_Preferred_Width again and then the full width of the requested rows checked again with Gtk.Cell_Area_Context.Get_Preferred_Width. Since: gtk+ 3.0 "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context which has already been requested for widths. "widget": the Gtk.Widget.Gtk_Widget where Area will be rendering "width": the width for which to check the height of this area "minimum_height": location to store the minimum height, or null "natural_height": location to store the natural height, or null

Get_Preferred_Width

procedure Get_Preferred_Width 
(Self: not null access Gtk_Cell_Area_Record;
Context: not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class;
Widget: not null access Gtk.Widget.Gtk_Widget_Record'Class;
Minimum_Width: out Gint;
Natural_Width: out Gint);
Retrieves a cell area's initial minimum and natural width. Area will store some geometrical information in Context along the way; when requesting sizes over an arbitrary number of rows, it's not important to check the Minimum_Width and Natural_Width of this call but rather to consult Gtk.Cell_Area_Context.Get_Preferred_Width after a series of requests. Since: gtk+ 3.0 "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context to perform this request with "widget": the Gtk.Widget.Gtk_Widget where Area will be rendering "minimum_width": location to store the minimum width, or null "natural_width": location to store the natural width, or null

Get_Preferred_Width_For_Height

procedure Get_Preferred_Width_For_Height 
(Self: not null access Gtk_Cell_Area_Record;
Context: not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class;
Widget: not null access Gtk.Widget.Gtk_Widget_Record'Class;
Height: Gint;
Minimum_Width: out Gint;
Natural_Width: out Gint);
Retrieves a cell area's minimum and natural width if it would be given the specified Height. Area stores some geometrical information in Context along the way while calling Gtk.Cell_Area.Get_Preferred_Height. It's important to perform a series of Gtk.Cell_Area.Get_Preferred_Height requests with Context first and then call Gtk.Cell_Area.Get_Preferred_Width_For_Height on each cell area individually to get the height for width of each fully requested row. If at some point, the height of a single row changes, it should be requested with Gtk.Cell_Area.Get_Preferred_Height again and then the full height of the requested rows checked again with Gtk.Cell_Area_Context.Get_Preferred_Height. Since: gtk+ 3.0 "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context which has already been requested for widths. "widget": the Gtk.Widget.Gtk_Widget where Area will be rendering "height": the height for which to check the width of this area "minimum_width": location to store the minimum width, or null "natural_width": location to store the natural width, or null

Get_Request_Mode

function Get_Request_Mode 
(Self: not null access Gtk_Cell_Area_Record) return Gtk.Enums.Gtk_Size_Request_Mode;
Gets whether the area prefers a height-for-width layout or a width-for-height layout. Since: gtk+ 3.0

Has_Renderer

function Has_Renderer 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class) return Boolean;
Checks if Area contains Renderer. Since: gtk+ 3.0 "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to check

Inner_Cell_Area

procedure Inner_Cell_Area 
(Self: not null access Gtk_Cell_Area_Record;
Widget: not null access Gtk.Widget.Gtk_Widget_Record'Class;
Cell_Area: Gdk.Rectangle.Gdk_Rectangle;
Inner_Area: out Gdk.Rectangle.Gdk_Rectangle);
This is a convenience function for Gtk.Cell_Area.Gtk_Cell_Area implementations to get the inner area where a given Gtk.Cell_Renderer.Gtk_Cell_Renderer will be rendered. It removes any padding previously added by Gtk.Cell_Area.Request_Renderer. Since: gtk+ 3.0 "widget": the Gtk.Widget.Gtk_Widget that Area is rendering onto "cell_area": the Widget relative coordinates where one of Area's cells is to be placed "inner_area": the return location for the inner cell area

Is_Activatable

function Is_Activatable 
(Self: not null access Gtk_Cell_Area_Record) return Boolean;
Returns whether the area can do anything when activated, after applying new attributes to Area. Since: gtk+ 3.0

Is_Focus_Sibling

function Is_Focus_Sibling 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Sibling: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class) return Boolean;
Returns whether Sibling is one of Renderer's focus siblings (see Gtk.Cell_Area.Add_Focus_Sibling). Since: gtk+ 3.0 "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer expected to have focus "sibling": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to check against Renderer's sibling list

Remove

procedure Remove 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class);
Removes Renderer from Area. Since: gtk+ 3.0 "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to remove from Area

Remove_Focus_Sibling

procedure Remove_Focus_Sibling 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Sibling: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class);
Removes Sibling from Renderer's focus sibling list (see Gtk.Cell_Area.Add_Focus_Sibling). Since: gtk+ 3.0 "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer expected to have focus "sibling": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to remove from Renderer's focus area

Render

procedure Render 
(Self: not null access Gtk_Cell_Area_Record;
Context: not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class;
Widget: not null access Gtk.Widget.Gtk_Widget_Record'Class;
Cr: Cairo.Cairo_Context;
Background_Area: Gdk.Rectangle.Gdk_Rectangle;
Cell_Area: Gdk.Rectangle.Gdk_Rectangle;
Flags: Gtk.Cell_Renderer.Gtk_Cell_Renderer_State;
Paint_Focus: Boolean);
Renders Area's cells according to Area's layout onto Widget at the given coordinates. Since: gtk+ 3.0 "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context for this row of data. "widget": the Gtk.Widget.Gtk_Widget that Area is rendering to "cr": the cairo_t to render with "background_area": the Widget relative coordinates for Area's background "cell_area": the Widget relative coordinates for Area "flags": the Gtk.Cell_Renderer.Gtk_Cell_Renderer_State for Area in this row. "paint_focus": whether Area should paint focus on focused cells for focused rows or not.

Request_Renderer

procedure Request_Renderer 
(Self: not null access Gtk_Cell_Area_Record;
Renderer: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Orientation: Gtk.Enums.Gtk_Orientation;
Widget: not null access Gtk.Widget.Gtk_Widget_Record'Class;
For_Size: Gint;
Minimum_Size: out Gint;
Natural_Size: out Gint);
This is a convenience function for Gtk.Cell_Area.Gtk_Cell_Area implementations to request size for cell renderers. It's important to use this function to request size and then use Gtk.Cell_Area.Inner_Cell_Area at render and event time since this function will add padding around the cell for focus painting. Since: gtk+ 3.0 "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to request size for "orientation": the Gtk.Enums.Gtk_Orientation in which to request size "widget": the Gtk.Widget.Gtk_Widget that Area is rendering onto "for_size": the allocation contextual size to request for, or -1 if the base request for the orientation is to be returned. "minimum_size": location to store the minimum size, or null "natural_size": location to store the natural size, or null

Stop_Editing

procedure Stop_Editing 
(Self: not null access Gtk_Cell_Area_Record;
Canceled: Boolean);
Explicitly stops the editing of the currently edited cell. If Canceled is True, the currently edited cell renderer will emit the ::editing-canceled signal, otherwise the the ::editing-done signal will be emitted on the current edit widget. See Gtk.Cell_Area.Get_Edited_Cell and Gtk.Cell_Area.Get_Edit_Widget. Since: gtk+ 3.0 "canceled": whether editing was canceled.

Set_Cell_Data_Func

procedure Set_Cell_Data_Func 
(Cell_Layout: not null access Gtk_Cell_Area_Record;
Cell: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Func: Gtk_Cell_Layout_Data_Func);
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

Get_Area

function Get_Area 
(Context: access Gtk_Cell_Area_Context_Record) return Gtk.Cell_Area.Gtk_Cell_Area;
Fetches the Gtk.Cell_Area.Gtk_Cell_Area this Context was created by. This is generally unneeded by layouting widgets; however it is important for the context implementation itself to fetch information about the area it is being used for. For instance at GtkCellAreaContextClass.allocate time its important to know details about any cell spacing that the Gtk.Cell_Area.Gtk_Cell_Area is configured with in order to compute a proper allocation. Since: gtk+ 3.0

Get_Area

function Get_Area 
(Cell_Layout: Gtk_Cell_Layout) return Gtk.Cell_Area.Gtk_Cell_Area;
Returns the underlying Gtk.Cell_Area.Gtk_Cell_Area which might be Cell_Layout if called on a Gtk.Cell_Area.Gtk_Cell_Area or might be null if no Gtk.Cell_Area.Gtk_Cell_Area is used by Cell_Layout. Since: gtk+ 3.0

Get_Cell_At_Position

procedure Get_Cell_At_Position 
(Self: access Gtk_Cell_Area_Record;
Context: access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class;
Widget: access Gtk.Widget.Gtk_Widget_Record'Class;
Cell_Area: Gdk.Rectangle.Gdk_Rectangle;
X: Gint;
Y: Gint;
Alloc_Area: out Gdk.Rectangle.Gdk_Rectangle;
Renderer: out Gtk.Cell_Renderer.Gtk_Cell_Renderer);
Gets the Gtk.Cell_Renderer.Gtk_Cell_Renderer at X and Y coordinates inside Area and optionally returns the full cell allocation for it inside Cell_Area. Since: gtk+ 3.0 "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context used to hold sizes for Area. "widget": the Gtk.Widget.Gtk_Widget that Area is rendering on "cell_area": the whole allocated area for Area in Widget for this row "x": the x position "y": the y position "alloc_area": where to store the inner allocated area of the returned cell renderer, or null. "renderer": the rendered that was found.

Add_Attribute

procedure Add_Attribute 
(Cell_Layout: not null access Gtk_Cell_Area_Record;
Cell: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Attribute: UTF8_String;
Column: Gint);

Clear

procedure Clear 
(Cell_Layout: not null access Gtk_Cell_Area_Record);

Clear_Attributes

procedure Clear_Attributes 
(Cell_Layout: not null access Gtk_Cell_Area_Record;
Cell: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class);

Get_Cells

function Get_Cells 
(Cell_Layout: not null access Gtk_Cell_Area_Record) return Glib.Object.Object_Simple_List.Glist;

Pack_End

procedure Pack_End 
(Cell_Layout: not null access Gtk_Cell_Area_Record;
Cell: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Expand: Boolean);

Pack_Start

procedure Pack_Start 
(Cell_Layout: not null access Gtk_Cell_Area_Record;
Cell: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Expand: Boolean);

Reorder

procedure Reorder 
(Cell_Layout: not null access Gtk_Cell_Area_Record;
Cell: not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Position: Gint);

On_Add_Editable

procedure On_Add_Editable 
(Self: not null access Gtk_Cell_Area_Record;
Call: Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_Gtk_Cell_Editable_Cairo_Rectangle_Int_UTF8_String_Void;
After: Boolean := False);

On_Add_Editable

procedure On_Add_Editable 
(Self: not null access Gtk_Cell_Area_Record;
Call: Cb_GObject_Gtk_Cell_Renderer_Gtk_Cell_Editable_Cairo_Rectangle_Int_UTF8_String_Void;
Slot: not null access Glib.Object.GObject_Record'Class;
After: Boolean := False);
Indicates that editing has started on Renderer and that Editable should be added to the owning cell-layouting widget at Cell_Area. Callback parameters: -- "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer that started the -- edited -- "editable": the Gtk.Cell_Editable.Gtk_Cell_Editable widget to add -- "cell_area": the Gtk.Widget.Gtk_Widget relative -- Gdk.Rectangle.Gdk_Rectangle coordinates where Editable should be added -- "path": the Gtk.Tree_Model.Gtk_Tree_Path string this edit was initiated -- for

On_Apply_Attributes

procedure On_Apply_Attributes 
(Self: not null access Gtk_Cell_Area_Record;
Call: Cb_Gtk_Cell_Area_Gtk_Tree_Model_Gtk_Tree_Iter_Boolean_Boolean_Void;
After: Boolean := False);

On_Apply_Attributes

procedure On_Apply_Attributes 
(Self: not null access Gtk_Cell_Area_Record;
Call: Cb_GObject_Gtk_Tree_Model_Gtk_Tree_Iter_Boolean_Boolean_Void;
Slot: not null access Glib.Object.GObject_Record'Class;
After: Boolean := False);
This signal is emitted whenever applying attributes to Area from Model Callback parameters: -- "model": the Gtk.Tree_Model.Gtk_Tree_Model to apply the attributes from -- "iter": the Gtk.Tree_Model.Gtk_Tree_Iter indicating which row to apply -- the attributes of -- "is_expander": whether the view shows children for this row -- "is_expanded": whether the view is currently showing the children of -- this row

On_Focus_Changed

procedure On_Focus_Changed 
(Self: not null access Gtk_Cell_Area_Record;
Call: Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_UTF8_String_Void;
After: Boolean := False);

On_Focus_Changed

procedure On_Focus_Changed 
(Self: not null access Gtk_Cell_Area_Record;
Call: Cb_GObject_Gtk_Cell_Renderer_UTF8_String_Void;
Slot: not null access Glib.Object.GObject_Record'Class;
After: Boolean := False);
Indicates that focus changed on this Area. This signal is emitted either as a result of focus handling or event handling. It's possible that the signal is emitted even if the currently focused renderer did not change, this is because focus may change to the same renderer in the same cell area for a different row of data. Callback parameters: -- "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer that has focus -- "path": the current Gtk.Tree_Model.Gtk_Tree_Path string set for Area

On_Remove_Editable

procedure On_Remove_Editable 
(Self: not null access Gtk_Cell_Area_Record;
Call: Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_Gtk_Cell_Editable_Void;
After: Boolean := False);

On_Remove_Editable

procedure On_Remove_Editable 
(Self: not null access Gtk_Cell_Area_Record;
Call: Cb_GObject_Gtk_Cell_Renderer_Gtk_Cell_Editable_Void;
Slot: not null access Glib.Object.GObject_Record'Class;
After: Boolean := False);
Indicates that editing finished on Renderer and that Editable should be removed from the owning cell-layouting widget. Callback parameters: -- "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer that finished -- editeding -- "editable": the Gtk.Cell_Editable.Gtk_Cell_Editable widget to remove