Index

Package: Cell_Renderer

Description

package Gtk.Cell_Renderer is

The Gtk_Cell_Renderer is a base class of a set of objects used for rendering a cell to a Gdk_Drawable. These objects are used primarily by the Gtk_Tree_View widget, though they aren't tied to them in any specific way.

It is worth noting that Gtk_Cell_Renderer is not a Gtk_Widget and cannot be treated as such.

The primary use of a Gtk_Cell_Renderer is for drawing a certain graphical elements on a Gdk_Drawable. Typically, one cell renderer is used to draw many cells on the screen. To this extent, it isn't expected that Cell_Renderer keep any permanent state around. Instead, any state is set just prior to use using GObjects property system. Then, the cell is measured using Get_Size(). Finally, the cell is rendered in the correct location using Render().

There are a number of rules that must be followed when writing a new Gtk_Cell_Renderer. First and formost, it's important that a certain set of properties will always yield a cell renderer of the same size, barring GtkStyle change. The Gtk_Cell_Renderer also has a number of generic properties that are expected to be honored by all children.

Beyond merely rendering a cell, cell renderers can optionally provide active user interface elements. A cell renderer can be activatable like Gtk_Cell_Renderer_Toggle, which toggles when it gets activated by a mouse click, or it can be editable like Gtk_Cell_Renderer_Text, which allows the user to edit the text using a Gtk_Entry. To make a cell renderer activatable or editable, you have to implement the activate or start_editing virtual functions, respectively.

Binding from C File version 2.14

Packages

Cell_Renderer_List (new Glib.Glist.Generic_List)

package Cell_Renderer_List is
      new Glib.Glist.Generic_List (Gtk_Cell_Renderer);

Classes

Gtk_Cell_Renderer_Record

type Gtk_Cell_Renderer_Record is
     new Glib.Object.GObject_Record with private;

Ancestors:

Immediate Children:

Primitive operations:

Get_Fixed_Size
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)
Set_Fixed_Size
Start_Editing

Types

Gtk_Cell_Renderer

type Gtk_Cell_Renderer is access all Gtk_Cell_Renderer_Record'Class;

Gtk_Cell_Renderer_State

type Gtk_Cell_Renderer_State is mod 2 ** 32;

Gtk_Cell_Renderer_Mode

type Gtk_Cell_Renderer_Mode is
     (Cell_Renderer_Mode_Inert,
      Cell_Renderer_Mode_Activatable,
      Cell_Renderer_Mode_Editable);

Property_Cell_Renderer_Mode

type Property_Cell_Renderer_Mode is
     new Cell_Renderer_Mode_Properties.Property;

Constants & Global variables

Cell_Renderer_Selected (Gtk_Cell_Renderer_State)

Cell_Renderer_Selected    : constant Gtk_Cell_Renderer_State;

Cell_Renderer_Prelit (Gtk_Cell_Renderer_State)

Cell_Renderer_Prelit      : constant Gtk_Cell_Renderer_State;

Cell_Renderer_Insensitive (Gtk_Cell_Renderer_State)

Cell_Renderer_Insensitive : constant Gtk_Cell_Renderer_State;

Cell_Renderer_Sorted (Gtk_Cell_Renderer_State)

Cell_Renderer_Sorted      : constant Gtk_Cell_Renderer_State;

Cell_Renderer_Focused (Gtk_Cell_Renderer_State)

Cell_Renderer_Focused     : constant Gtk_Cell_Renderer_State;
Identifies how a cell should be renderer. Prelit is used when the mouse is hovering over a particular cell. Sorted is used when the cell is in a sort row.

Signal_Editing_Canceled (Glib.Signal_Name)

Signal_Editing_Canceled : constant Glib.Signal_Name := "editing-canceled";

Signal_Editing_Started (Glib.Signal_Name)

Signal_Editing_Started  : constant Glib.Signal_Name := "editing-started";

Cell_Background_Property (Glib.Properties.Property_String)

Cell_Background_Property     : constant Glib.Properties.Property_String;
Cell_Background_Gdk_Property : constant Glib.Properties.Property_Boxed;

Editing_Property (Glib.Properties.Property_Boolean)

Editing_Property             : constant Glib.Properties.Property_Boolean;
Cell_Background_Gdk_Property : constant Glib.Properties.Property_Boxed;

Is_Expanded_Property (Glib.Properties.Property_Boolean)

Is_Expanded_Property         : constant Glib.Properties.Property_Boolean;

Is_Expander_Property (Glib.Properties.Property_Boolean)

Is_Expander_Property         : constant Glib.Properties.Property_Boolean;

Subprograms & Entries

Convert

function Convert 
(R: Gtk_Cell_Renderer) return System.Address;

Convert

function Convert 
(R: System.Address) return Gtk_Cell_Renderer;

Get_Type

function Get_Type return GType;
Return the internal value associated with Gtk_Cell_Renderer

Get_Size

procedure Get_Size 
(Cell: access Gtk_Cell_Renderer_Record;
Widget: access Gtk.Widget.Gtk_Widget_Record'Class;
Cell_Area: out Gdk.Rectangle.Gdk_Rectangle;
X_Offset: out Gint;
Y_Offset: out Gint;
Width: out Gint;
Height: out Gint);
Obtain the width and height needed to render the cell. Used by view widgets to determine the appropriate size for the Cell_Area passed to Render. Fill in the x and y offsets (if set) of the cell relative to this location. Please note that the values set in Width and Height, as well as those in X_Offset and Y_Offset are inclusive of the Xpad and Ypad properties. Widget: the widget the renderer is rendering to. Cell_Area: The area a cell will be allocated. X_Offset: X offset of cell relative to Cell_Area. Y_Offset: Y offset of cell relative to Cell_Area. Width: Width needed to render a cell. Height: Height needed to render a cell.

Render

Invokes the virtual render function of the Gtk_Cell_Renderer. The three passed-in rectangles are areas of Window. Most renderers will draw within Cell_Area; the Xalign, Yalign, Xpad, and Ypad fields of the GtkCellRenderer should be honored with respect to Cell_Area. Background_Area includes the blank space around the cell, and also the area containing the tree expander; so the Background_Area rectangles for all cells tile to cover the entire Window. Expose_Area is a clip rectangle.

Activate

function Activate 
(Cell: access Gtk_Cell_Renderer_Record;
Event: Gdk.Event.Gdk_Event;
Widget: access Gtk.Widget.Gtk_Widget_Record'Class;
Path: UTF8_String;
Background_Area: Gdk.Rectangle.Gdk_Rectangle;
Cell_Area: Gdk.Rectangle.Gdk_Rectangle;
Flags: Gtk_Cell_Renderer_State) return Boolean;
Passes an activate event to the cell renderer for possible processing. Some cell renderers may use events; for example, Gtk_Cell_Renderer_Toggle toggles when it gets a mouse click.

Start_Editing

Passes an activate event to the cell renderer for possible processing. Cell: a Gtk_Cell_Renderer Event: a Gdk_Event Widget: widget that received the event Path: widget-dependent string representation of the event location; e.g. for Gtk_Tree_View, a string representation of Gtk_Tree_Path Background_Area: background area as passed to Render Cell_Area: cell area as passed to Render

Set_Fixed_Size

procedure Set_Fixed_Size 
(Cell: access Gtk_Cell_Renderer_Record;
Width: Gint;
Height: Gint);

Get_Fixed_Size

procedure Get_Fixed_Size 
(Cell: access Gtk_Cell_Renderer_Record;
Width: out Gint;
Height: out Gint);
Sets the renderer size to be explicit, independent of the properties set.