------------------------------------------------------------------------------ -- -- -- 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> -- The Gtk.Cell_Renderer.Gtk_Cell_Renderer is a base class of a set of -- objects used for rendering a cell to a cairo_t. These objects are used -- primarily by the Gtk.Tree_View.Gtk_Tree_View widget, though they aren't -- tied to them in any specific way. It is worth noting that -- Gtk.Cell_Renderer.Gtk_Cell_Renderer is not a Gtk.Widget.Gtk_Widget and -- cannot be treated as such. -- -- The primary use of a Gtk.Cell_Renderer.Gtk_Cell_Renderer is for drawing a -- certain graphical elements on a cairo_t. Typically, one cell renderer is -- used to draw many cells on the screen. To this extent, it isn't expected -- that a CellRenderer keep any permanent state around. Instead, any state is -- set just prior to use using GObjects property system. Then, the cell is -- measured using Gtk.Cell_Renderer.Get_Size. Finally, the cell is rendered in -- the correct location using Gtk.Cell_Renderer.Render. -- -- There are a number of rules that must be followed when writing a new -- Gtk.Cell_Renderer.Gtk_Cell_Renderer. First and foremost, it's important -- that a certain set of properties will always yield a cell renderer of the -- same size, barring a Gtk.Style.Gtk_Style change. The -- Gtk.Cell_Renderer.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.Gtk_Cell_Renderer_Toggle, which toggles when it -- gets activated by a mouse click, or it can be 'editable' like -- Gtk.Cell_Renderer_Text.Gtk_Cell_Renderer_Text, which allows the user to -- edit the text using a Gtk.GEntry.Gtk_Entry. To make a cell renderer -- activatable or editable, you have to implement the -- Gtk.Cell_Renderer_Class.Gtk_Cell_Renderer_Class.activate or -- Gtk.Cell_Renderer_Class.Gtk_Cell_Renderer_Class.start_editing virtual -- functions, respectively. -- -- Many properties of Gtk.Cell_Renderer.Gtk_Cell_Renderer and its subclasses -- have a corresponding "set" property, e.g. "cell-background-set" corresponds -- to "cell-background". These "set" properties reflect whether a property has -- been set or not. You should not set them independently. -- -- </description> pragma Ada_2005; pragma Warnings (Off, "*is already use-visible*");
with Cairo; use Cairo;
with Gdk.Color; use Gdk.Color;
with Gdk.Event; use Gdk.Event;
with Gdk.RGBA; use Gdk.RGBA;
with Gdk.Rectangle; use Gdk.Rectangle;
with Glib; use Glib;
with Glib.Generic_Properties; use Glib.Generic_Properties;
with Glib.Glist; use Glib.Glist;
with Glib.Object; use Glib.Object;
with Glib.Properties; use Glib.Properties;
with Gtk.Cell_Editable; use Gtk.Cell_Editable;
with Gtk.Enums; use Gtk.Enums;
with Gtk.Widget; use Gtk.Widget;
package Gtk.Cell_Renderer is
type Gtk_Cell_Renderer_Record is new GObject_Record with null record;
type Gtk_Cell_Renderer is access all Gtk_Cell_Renderer_Record'Class;
type Gtk_Cell_Renderer_State is mod 2 ** Integer'Size;
pragma Convention (C, Gtk_Cell_Renderer_State);
-- Tells how a cell is to be rendered. Cell_Renderer_Selected : constant Gtk_Cell_Renderer_State := 1;
Cell_Renderer_Prelit : constant Gtk_Cell_Renderer_State := 2;
Cell_Renderer_Insensitive : constant Gtk_Cell_Renderer_State := 4;
Cell_Renderer_Sorted : constant Gtk_Cell_Renderer_State := 8;
Cell_Renderer_Focused : constant Gtk_Cell_Renderer_State := 16;
Cell_Renderer_Expandable : constant Gtk_Cell_Renderer_State := 32;
Cell_Renderer_Expanded : constant Gtk_Cell_Renderer_State := 64;
type Gtk_Cell_Renderer_Mode is (
Cell_Renderer_Mode_Inert,
Cell_Renderer_Mode_Activatable,
Cell_Renderer_Mode_Editable);
pragma Convention (C, Gtk_Cell_Renderer_Mode);
-- Identifies how the user can interact with a particular cell. function Convert (R : Gtk.Cell_Renderer.Gtk_Cell_Renderer) return System.Address;
function Convert (R : System.Address) return Gtk.Cell_Renderer.Gtk_Cell_Renderer;
package Cell_Renderer_List is new Generic_List (Gtk.Cell_Renderer.Gtk_Cell_Renderer);
---------------------------- -- Enumeration Properties -- ---------------------------- package Gtk_Cell_Renderer_State_Properties is
new Generic_Internal_Discrete_Property (Gtk_Cell_Renderer_State);
type Property_Gtk_Cell_Renderer_State is new Gtk_Cell_Renderer_State_Properties.Property;
package Gtk_Cell_Renderer_Mode_Properties is
new Generic_Internal_Discrete_Property (Gtk_Cell_Renderer_Mode);
type Property_Gtk_Cell_Renderer_Mode is new Gtk_Cell_Renderer_Mode_Properties.Property;
------------------ -- Constructors -- ------------------ function Get_Type return Glib.GType;
pragma Import (C, Get_Type, "gtk_cell_renderer_get_type");
------------- -- Methods -- ------------- function Activate
(Cell : not null access Gtk_Cell_Renderer_Record;
Event : Gdk.Event.Gdk_Event;
Widget : not null 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.Gtk_Cell_Renderer_Toggle toggles when it gets a -- mouse click. -- "event": a Gdk.Event.Gdk_Event -- "widget": widget that received the event -- "path": widget-dependent string representation of the event location; -- e.g. for Gtk.Tree_View.Gtk_Tree_View, a string representation of -- Gtk.Tree_Model.Gtk_Tree_Path -- "background_area": background area as passed to -- Gtk.Cell_Renderer.Render -- "cell_area": cell area as passed to Gtk.Cell_Renderer.Render -- "flags": render flags procedure Get_Aligned_Area
(Cell : not null access Gtk_Cell_Renderer_Record;
Widget : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Flags : Gtk_Cell_Renderer_State;
Cell_Area : Gdk.Rectangle.Gdk_Rectangle;
Aligned_Area : out Gdk.Rectangle.Gdk_Rectangle);
-- Gets the aligned area used by Cell inside Cell_Area. Used for finding -- the appropriate edit and focus rectangle. -- Since: gtk+ 3.0 -- "widget": the Gtk.Widget.Gtk_Widget this cell will be rendering to -- "flags": render flags -- "cell_area": cell area which would be passed to -- Gtk.Cell_Renderer.Render -- "aligned_area": the return location for the space inside Cell_Area that -- would acually be used to render. procedure Get_Alignment
(Cell : not null access Gtk_Cell_Renderer_Record;
Xalign : out Gfloat;
Yalign : out Gfloat);
-- Fills in Xalign and Yalign with the appropriate values of Cell. -- Since: gtk+ 2.18 -- "xalign": location to fill in with the x alignment of the cell, or null -- "yalign": location to fill in with the y alignment of the cell, or null procedure Set_Alignment
(Cell : not null access Gtk_Cell_Renderer_Record;
Xalign : Gfloat;
Yalign : Gfloat);
-- Sets the renderer's alignment within its available space. -- Since: gtk+ 2.18 -- "xalign": the x alignment of the cell renderer -- "yalign": the y alignment of the cell renderer procedure Get_Fixed_Size
(Cell : not null access Gtk_Cell_Renderer_Record;
Width : out Gint;
Height : out Gint);
-- Fills in Width and Height with the appropriate size of Cell. -- "width": location to fill in with the fixed width of the cell, or null -- "height": location to fill in with the fixed height of the cell, or -- null procedure Set_Fixed_Size
(Cell : not null access Gtk_Cell_Renderer_Record;
Width : Gint;
Height : Gint);
-- Sets the renderer size to be explicit, independent of the properties -- set. -- "width": the width of the cell renderer, or -1 -- "height": the height of the cell renderer, or -1 procedure Get_Padding
(Cell : not null access Gtk_Cell_Renderer_Record;
Xpad : out Gint;
Ypad : out Gint);
-- Fills in Xpad and Ypad with the appropriate values of Cell. -- Since: gtk+ 2.18 -- "xpad": location to fill in with the x padding of the cell, or null -- "ypad": location to fill in with the y padding of the cell, or null procedure Set_Padding
(Cell : not null access Gtk_Cell_Renderer_Record;
Xpad : Gint;
Ypad : Gint);
-- Sets the renderer's padding. -- Since: gtk+ 2.18 -- "xpad": the x padding of the cell renderer -- "ypad": the y padding of the cell renderer procedure Get_Preferred_Height
(Cell : not null access Gtk_Cell_Renderer_Record;
Widget : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Minimum_Size : out Gint;
Natural_Size : out Gint);
-- Retreives a renderer's natural size when rendered to Widget. -- Since: gtk+ 3.0 -- "widget": the Gtk.Widget.Gtk_Widget this cell will be rendering to -- "minimum_size": location to store the minimum size, or null -- "natural_size": location to store the natural size, or null procedure Get_Preferred_Height_For_Width
(Cell : not null access Gtk_Cell_Renderer_Record;
Widget : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Width : Gint;
Minimum_Height : out Gint;
Natural_Height : out Gint);
-- Retreives a cell renderers's minimum and natural height if it were -- rendered to Widget with the specified Width. -- Since: gtk+ 3.0 -- "widget": the Gtk.Widget.Gtk_Widget this cell will be rendering to -- "width": the size which is available for allocation -- "minimum_height": location for storing the minimum size, or null -- "natural_height": location for storing the preferred size, or null procedure Get_Preferred_Size
(Cell : not null access Gtk_Cell_Renderer_Record;
Widget : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Minimum_Size : out Gtk.Widget.Gtk_Requisition;
Natural_Size : out Gtk.Widget.Gtk_Requisition);
-- Retrieves the minimum and natural size of a cell taking into account -- the widget's preference for height-for-width management. -- Since: gtk+ 3.0 -- "widget": the Gtk.Widget.Gtk_Widget this cell will be rendering to -- "minimum_size": location for storing the minimum size, or null -- "natural_size": location for storing the natural size, or null procedure Get_Preferred_Width
(Cell : not null access Gtk_Cell_Renderer_Record;
Widget : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Minimum_Size : out Gint;
Natural_Size : out Gint);
-- Retreives a renderer's natural size when rendered to Widget. -- Since: gtk+ 3.0 -- "widget": the Gtk.Widget.Gtk_Widget this cell will be rendering to -- "minimum_size": location to store the minimum size, or null -- "natural_size": location to store the natural size, or null procedure Get_Preferred_Width_For_Height
(Cell : not null access Gtk_Cell_Renderer_Record;
Widget : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Height : Gint;
Minimum_Width : out Gint;
Natural_Width : out Gint);
-- Retreives a cell renderers's minimum and natural width if it were -- rendered to Widget with the specified Height. -- Since: gtk+ 3.0 -- "widget": the Gtk.Widget.Gtk_Widget this cell will be rendering to -- "height": the size which is available for allocation -- "minimum_width": location for storing the minimum size, or null -- "natural_width": location for storing the preferred size, or null function Get_Request_Mode
(Cell : not null access Gtk_Cell_Renderer_Record)
return Gtk.Enums.Gtk_Size_Request_Mode;
-- Gets whether the cell renderer prefers a height-for-width layout or a -- width-for-height layout. -- Since: gtk+ 3.0 function Get_Sensitive
(Cell : not null access Gtk_Cell_Renderer_Record) return Boolean;
-- Returns the cell renderer's sensitivity. -- Since: gtk+ 2.18 procedure Set_Sensitive
(Cell : not null access Gtk_Cell_Renderer_Record;
Sensitive : Boolean);
-- Sets the cell renderer's sensitivity. -- Since: gtk+ 2.18 -- "sensitive": the sensitivity of the cell procedure Get_Size
(Cell : not null access Gtk_Cell_Renderer_Record;
Widget : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Cell_Area : in out Gdk.Rectangle.Gdk_Rectangle;
X_Offset : out Gint;
Y_Offset : out Gint;
Width : out Gint;
Height : out Gint);
pragma Obsolescent (Get_Size);
-- Obtains the width and height needed to render the cell. Used by view -- widgets to determine the appropriate size for the cell_area passed to -- Gtk.Cell_Renderer.Render. If Cell_Area is not null, fills 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. -- Deprecated since 3.0, Use Gtk.Cell_Renderer.Get_Preferred_Size instead. -- "widget": the widget the renderer is rendering to -- "cell_area": The area a cell will be allocated, or null -- "x_offset": location to return x offset of cell relative to Cell_Area, -- or null -- "y_offset": location to return y offset of cell relative to Cell_Area, -- or null -- "width": location to return width needed to render a cell, or null -- "height": location to return height needed to render a cell, or null function Get_State
(Cell : not null access Gtk_Cell_Renderer_Record;
Widget : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Cell_State : Gtk_Cell_Renderer_State)
return Gtk.Enums.Gtk_State_Flags;
-- Translates the cell renderer state to Gtk.Enums.Gtk_State_Flags, based -- on the cell renderer and widget sensitivity, and the given -- Gtk.Cell_Renderer.Gtk_Cell_Renderer_State. -- Since: gtk+ 3.0 -- "widget": a Gtk.Widget.Gtk_Widget, or null -- "cell_state": cell renderer state function Get_Visible
(Cell : not null access Gtk_Cell_Renderer_Record) return Boolean;
-- Returns the cell renderer's visibility. -- Since: gtk+ 2.18 procedure Set_Visible
(Cell : not null access Gtk_Cell_Renderer_Record;
Visible : Boolean);
-- Sets the cell renderer's visibility. -- Since: gtk+ 2.18 -- "visible": the visibility of the cell function Is_Activatable
(Cell : not null access Gtk_Cell_Renderer_Record) return Boolean;
-- Checks whether the cell renderer can do something when activated. -- Since: gtk+ 3.0 procedure Render
(Cell : not null access Gtk_Cell_Renderer_Record;
Cr : Cairo.Cairo_Context;
Widget : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Background_Area : Gdk.Rectangle.Gdk_Rectangle;
Cell_Area : Gdk.Rectangle.Gdk_Rectangle;
Flags : Gtk_Cell_Renderer_State);
-- Invokes the virtual render function of the -- Gtk.Cell_Renderer.Gtk_Cell_Renderer. The three passed-in rectangles are -- areas in Cr. Most renderers will draw within Cell_Area; the xalign, -- yalign, xpad, and ypad fields of the Gtk.Cell_Renderer.Gtk_Cell_Renderer -- 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. -- "cr": a cairo context to draw to -- "widget": the widget owning Window -- "background_area": entire cell area (including tree expanders and maybe -- padding on the sides) -- "cell_area": area normally rendered by a cell renderer -- "flags": flags that affect rendering function Start_Editing
(Cell : not null access Gtk_Cell_Renderer_Record;
Event : Gdk.Event.Gdk_Event;
Widget : not null 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 Gtk.Cell_Editable.Gtk_Cell_Editable;
-- Passes an activate event to the cell renderer for possible processing. -- "event": a Gdk.Event.Gdk_Event -- "widget": widget that received the event -- "path": widget-dependent string representation of the event location; -- e.g. for Gtk.Tree_View.Gtk_Tree_View, a string representation of -- Gtk.Tree_Model.Gtk_Tree_Path -- "background_area": background area as passed to -- Gtk.Cell_Renderer.Render -- "cell_area": cell area as passed to Gtk.Cell_Renderer.Render -- "flags": render flags procedure Stop_Editing
(Cell : not null access Gtk_Cell_Renderer_Record;
Canceled : Boolean);
-- Informs the cell renderer that the editing is stopped. If Canceled is -- True, the cell renderer will emit the -- Gtk.Cell_Renderer.Gtk_Cell_Renderer::editing-canceled signal. -- This function should be called by cell renderer implementations in -- response to the Gtk.Cell_Editable.Gtk_Cell_Editable::editing-done signal -- of Gtk.Cell_Editable.Gtk_Cell_Editable. -- Since: gtk+ 2.6 -- "canceled": True if the editing has been canceled ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Cell_Background_Property : constant Glib.Properties.Property_String;
-- Flags: write Cell_Background_Gdk_Property : constant Gdk.Color.Property_Gdk_Color;
-- Type: Gdk.Color.Gdk_Color -- Cell background as a Gdk.Color.Gdk_Color Cell_Background_Rgba_Property : constant Gdk.RGBA.Property_RGBA;
-- Type: Gdk.RGBA.Gdk_RGBA -- Cell background as a Gdk.RGBA.Gdk_RGBA Cell_Background_Set_Property : constant Glib.Properties.Property_Boolean;
Editing_Property : constant Glib.Properties.Property_Boolean;
Height_Property : constant Glib.Properties.Property_Int;
Is_Expanded_Property : constant Glib.Properties.Property_Boolean;
Is_Expander_Property : constant Glib.Properties.Property_Boolean;
Mode_Property : constant Gtk.Cell_Renderer.Property_Gtk_Cell_Renderer_Mode;
-- Type: Gtk_Cell_Renderer_Mode Sensitive_Property : constant Glib.Properties.Property_Boolean;
Visible_Property : constant Glib.Properties.Property_Boolean;
Width_Property : constant Glib.Properties.Property_Int;
Xalign_Property : constant Glib.Properties.Property_Float;
Xpad_Property : constant Glib.Properties.Property_Uint;
Yalign_Property : constant Glib.Properties.Property_Float;
Ypad_Property : constant Glib.Properties.Property_Uint;
------------- -- Signals -- ------------- type Cb_Gtk_Cell_Renderer_Void is not null access procedure
(Self : access Gtk_Cell_Renderer_Record'Class);
type Cb_GObject_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class);
Signal_Editing_Canceled : constant Glib.Signal_Name := "editing-canceled";
procedure On_Editing_Canceled
(Self : not null access Gtk_Cell_Renderer_Record;
Call : Cb_Gtk_Cell_Renderer_Void;
After : Boolean := False);
procedure On_Editing_Canceled
(Self : not null access Gtk_Cell_Renderer_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- This signal gets emitted when the user cancels the process of editing a -- cell. For example, an editable cell renderer could be written to cancel -- editing when the user presses Escape. -- -- See also: Gtk.Cell_Renderer.Stop_Editing. type Cb_Gtk_Cell_Renderer_Gtk_Cell_Editable_UTF8_String_Void is not null access procedure
(Self : access Gtk_Cell_Renderer_Record'Class;
Editable : Gtk.Cell_Editable.Gtk_Cell_Editable; Path : UTF8_String); type Cb_GObject_Gtk_Cell_Editable_UTF8_String_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Editable : Gtk.Cell_Editable.Gtk_Cell_Editable; Path : UTF8_String); Signal_Editing_Started : constant Glib.Signal_Name := "editing-started";
procedure On_Editing_Started
(Self : not null access Gtk_Cell_Renderer_Record;
Call : Cb_Gtk_Cell_Renderer_Gtk_Cell_Editable_UTF8_String_Void;
After : Boolean := False);
procedure On_Editing_Started
(Self : not null access Gtk_Cell_Renderer_Record;
Call : Cb_GObject_Gtk_Cell_Editable_UTF8_String_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- This signal gets emitted when a cell starts to be edited. The intended -- use of this signal is to do special setup on Editable, e.g. adding a -- Gtk.Entry_Completion.Gtk_Entry_Completion or setting up additional -- columns in a Gtk.Combo_Box.Gtk_Combo_Box. -- -- Note that GTK+ doesn't guarantee that cell renderers will continue to -- use the same kind of widget for editing in future releases, therefore -- you should check the type of Editable before doing any specific setup, -- as in the following example: |[ static void text_editing_started -- (GtkCellRenderer *cell, GtkCellEditable *editable, const gchar *path, -- gpointer data) { if (GTK_IS_ENTRY (editable)) { GtkEntry *entry = -- GTK_ENTRY (editable); /* ... create a GtkEntryCompletion */ -- gtk_entry_set_completion (entry, completion); } } ]| -- -- Callback parameters: -- -- "editable": the Gtk.Cell_Editable.Gtk_Cell_Editable -- -- "path": the path identifying the edited cell private Ypad_Property : constant Glib.Properties.Property_Uint :=
Glib.Properties.Build ("ypad");
Yalign_Property : constant Glib.Properties.Property_Float :=
Glib.Properties.Build ("yalign");
Xpad_Property : constant Glib.Properties.Property_Uint :=
Glib.Properties.Build ("xpad");
Xalign_Property : constant Glib.Properties.Property_Float :=
Glib.Properties.Build ("xalign");
Width_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("width");
Visible_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("visible");
Sensitive_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("sensitive");
Mode_Property : constant Gtk.Cell_Renderer.Property_Gtk_Cell_Renderer_Mode :=
Gtk.Cell_Renderer.Build ("mode");
Is_Expander_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("is-expander");
Is_Expanded_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("is-expanded");
Height_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("height");
Editing_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("editing");
Cell_Background_Set_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("cell-background-set");
Cell_Background_Rgba_Property : constant Gdk.RGBA.Property_RGBA :=
Gdk.RGBA.Build ("cell-background-rgba");
Cell_Background_Gdk_Property : constant Gdk.Color.Property_Gdk_Color :=
Gdk.Color.Build ("cell-background-gdk");
Cell_Background_Property : constant Glib.Properties.Property_String :=
Glib.Properties.Build ("cell-background");
end Gtk.Cell_Renderer;