Back to Seed Clases

Gtk

Classes

Interfaces

Structs

Unions

Enums

GObject.Object
parent-child marker GObject.InitiallyUnowned
Gtk.CellRenderer

Class Gtk.CellRenderer

Import line:	Gtk = imports.gi.Gtk;
GIR File:	Gtk-3.0.gir
C documentation:	GtkCellRenderer
Class :	CellRenderer
Extends:	GObject.InitiallyUnowned

The GtkCellRenderer 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 GtkTreeView widget, though they aren't tied to them in any
specific way. It is worth noting that GtkCellRenderer is not a
GtkWidget and cannot be treated as such.
The primary use of a GtkCellRenderer 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
GtkCellRenderer. First and formost, its important that a certain set
of properties will always yield a cell renderer of the same size,
barring a GtkStyle change. The GtkCellRenderer 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 GtkCellRendererToggle,
which toggles when it gets activated by a mouse click, or it can be
editable like GtkCellRendererText, which
allows the user to edit the text using a GtkEntry.
To make a cell renderer activatable or editable, you have to
implement the GtkCellRendererClass.activate or
GtkCellRendererClass.start_editing virtual functions, respectively.

Properties
Properties		Defined By
	cell_background : String	Gtk.CellRenderer
	cell_background_gdk : Gdk.Color	Gtk.CellRenderer
	cell_background_rgba : Gdk.RGBA Cell background as a GdkRGBA Cell background as a GdkRGBA	Gtk.CellRenderer
	cell_background_set : gboolean	Gtk.CellRenderer
	editing : gboolean read only	Gtk.CellRenderer
	g_type_instance : GObject.TypeInstance	GObject.InitiallyUnowned
	height : gint32	Gtk.CellRenderer
	is_expanded : gboolean	Gtk.CellRenderer
	is_expander : gboolean	Gtk.CellRenderer
	mode : Gtk.CellRendererMode	Gtk.CellRenderer
	parent_instance : GObject.InitiallyUnowned read only	Gtk.CellRenderer
	priv : Gtk.CellRendererPrivate read only	Gtk.CellRenderer
	qdata : GLib.Data read only	GObject.InitiallyUnowned
	ref_count : guint32 read only	GObject.InitiallyUnowned
	sensitive : gboolean	Gtk.CellRenderer
	visible : gboolean	Gtk.CellRenderer
	width : gint32	Gtk.CellRenderer
	xalign : gfloat	Gtk.CellRenderer
	xpad : guint32	Gtk.CellRenderer
	yalign : gfloat	Gtk.CellRenderer
	ypad : guint32	Gtk.CellRenderer

Methods / Constructors
Method / Constructor		Defined By
	new Gtk.CellRenderer (Object *properties) Create a new Gtk.CellRenderer Create a new Gtk.CellRenderer Parameters: Object properties*
	activate (Event *event, Widget widget, String path, RectangleInt background_area, RectangleInt cell_area, CellRendererState flags) : gboolean Passes an activate event to the cell renderer for possible processing. Passes an activate event to the cell renderer for possible processing. Some cell renderers may use events; for example, GtkCellRendererToggle* toggles when it gets a mouse click. Parameters: Gdk.Event event Required (not null) a GdkEvent Gtk.Widget widget Required (not null) widget that received the event String path Required (not null) widget-dependent string representation of the event location; e.g. for GtkTreeView, a string representation of GtkTreePath cairo.RectangleInt background_area Required (not null) background area as passed to gtk_cell_renderer_render() cairo.RectangleInt cell_area Required (not null) cell area as passed to gtk_cell_renderer_render() Gtk.CellRendererState flags Required (not null) render flags Returns: gboolean TRUE if the event was consumed/handled	Gtk.CellRenderer
	get_aligned_area (Widget *widget, CellRendererState flags, RectangleInt cell_area) : cairo.RectangleInt Gets the aligned area used by cell* inside cell_area. Gets the aligned area used by cell inside cell_area. Used for finding the appropriate edit and focus rectangle. Parameters: Gtk.Widget widget Required (not null) the GtkWidget this cell will be rendering to Gtk.CellRendererState flags Required (not null) render flags cairo.RectangleInt cell_area Required (not null) cell area which would be passed to gtk_cell_renderer_render() Returns: cairo.RectangleInt	Gtk.CellRenderer
	get_alignment () : Object Fills in xalign and yalign with the appropriate values of cell. Fills in xalign and yalign with the appropriate values of cell. Returns: xalign: gfloat yalign: gfloat	Gtk.CellRenderer
	get_fixed_size () : Object Fills in width and height with the appropriate size of cell. Fills in width and height with the appropriate size of cell. Returns: width: gint32 height: gint32	Gtk.CellRenderer
	get_padding () : Object Fills in xpad and ypad with the appropriate values of cell. Fills in xpad and ypad with the appropriate values of cell. Returns: xpad: gint32 ypad: gint32	Gtk.CellRenderer
	get_preferred_height (Widget *widget) : Object Retreives a renderer's natural size when rendered to widget. Retreives a renderer's natural size when rendered to widget. Parameters: Gtk.Widget widget* Required (not null) the GtkWidget this cell will be rendering to Returns: minimum_size: gint32 natural_size: gint32	Gtk.CellRenderer
	get_preferred_height_for_width (Widget *widget, gint32 width) : Object Retreives a cell renderers's minimum and natural height if it were rendered to Retreives a cell renderers's minimum and natural height if it were rendered to Parameters: Gtk.Widget widget* Required (not null) the GtkWidget this cell will be rendering to gint32 width Required (not null) the size which is available for allocation Returns: minimum_height: gint32 natural_height: gint32	Gtk.CellRenderer
	get_preferred_size (Widget *widget) : Object Retrieves the minimum and natural size of a cell taking into account the widget's preference for height-for-width management. Retrieves the minimum and natural size of a cell taking into account the widget's preference for height-for-width management. Parameters: Gtk.Widget widget* Required (not null) the GtkWidget this cell will be rendering to Returns: minimum_size: Gtk.Requisition natural_size: Gtk.Requisition	Gtk.CellRenderer
	get_preferred_width (Widget *widget) : Object Retreives a renderer's natural size when rendered to widget. Retreives a renderer's natural size when rendered to widget. Parameters: Gtk.Widget widget* Required (not null) the GtkWidget this cell will be rendering to Returns: minimum_size: gint32 natural_size: gint32	Gtk.CellRenderer
	get_preferred_width_for_height (Widget *widget, gint32 height) : Object Retreives a cell renderers's minimum and natural width if it were rendered to Retreives a cell renderers's minimum and natural width if it were rendered to Parameters: Gtk.Widget widget* Required (not null) the GtkWidget this cell will be rendering to gint32 height Required (not null) the size which is available for allocation Returns: minimum_width: gint32 natural_width: gint32	Gtk.CellRenderer
	get_request_mode () : Gtk.SizeRequestMode Gets whether the cell renderer prefers a height-for-width layout or a width-for-height layout. Gets whether the cell renderer prefers a height-for-width layout or a width-for-height layout. Returns: Gtk.SizeRequestMode The GtkSizeRequestMode preferred by this renderer.	Gtk.CellRenderer
	get_sensitive () : gboolean Returns the cell renderer's sensitivity. Returns the cell renderer's sensitivity. Returns: gboolean TRUE if the cell renderer is sensitive	Gtk.CellRenderer
	get_size (Widget *widget, RectangleInt cell_area) : Object Obtains the width and height needed to render the cell. 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. Parameters: Gtk.Widget widget Required (not null) the widget the renderer is rendering to cairo.RectangleInt cell_area The area a cell will be allocated, or NULL Returns: x_offset: gint32 y_offset: gint32 width: gint32 height: gint32	Gtk.CellRenderer
	get_state (Widget *widget, CellRendererState cell_state) : Gtk.StateFlags Translates the cell renderer state to GtkStateFlags, based on the cell renderer and widget sensitivity, and the given GtkCellRendererState. Translates the cell renderer state to GtkStateFlags, based on the cell renderer and widget sensitivity, and the given GtkCellRendererState. Parameters: Gtk.Widget widget* Required (not null) a GtkWidget, or NULL Gtk.CellRendererState cell_state Required (not null) cell renderer state Returns: Gtk.StateFlags the widget state flags applying to cell	Gtk.CellRenderer
	get_visible () : gboolean Returns the cell renderer's visibility. Returns the cell renderer's visibility. Returns: gboolean TRUE if the cell renderer is visible	Gtk.CellRenderer
	is_activatable () : gboolean Checks whether the cell renderer can do something when activated. Checks whether the cell renderer can do something when activated. Returns: gboolean TRUE if the cell renderer can do anything when activated	Gtk.CellRenderer
	render (Context cr, Widget *widget, RectangleInt background_area, RectangleInt cell_area, CellRendererState flags) : none Invokes the virtual render function of the GtkCellRenderer. Invokes the virtual render function of the GtkCellRenderer. The three passed-in rectangles are areas in cr. Most renderers will draw within 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 Parameters: cairo.Context cr Required (not null) a cairo context to draw to Gtk.Widget widget Required (not null) the widget owning window cairo.RectangleInt background_area Required (not null) entire cell area (including tree expanders and maybe padding on the sides) cairo.RectangleInt cell_area Required (not null) area normally rendered by a cell renderer Gtk.CellRendererState flags Required (not null) flags that affect rendering Returns: none	Gtk.CellRenderer
	set_alignment (gfloat *xalign, gfloat yalign) : none Sets the renderer's alignment within its available space. Sets the renderer's alignment within its available space. Parameters: gfloat xalign* Required (not null) the x alignment of the cell renderer gfloat yalign Required (not null) the y alignment of the cell renderer Returns: none	Gtk.CellRenderer
	set_fixed_size (gint32 *width, gint32 height) : none Sets the renderer size to be explicit, independent of the properties set. Sets the renderer size to be explicit, independent of the properties set. Parameters: gint32 width* Required (not null) the width of the cell renderer, or -1 gint32 height Required (not null) the height of the cell renderer, or -1 Returns: none	Gtk.CellRenderer
	set_padding (gint32 *xpad, gint32 ypad) : none Sets the renderer's padding. Sets the renderer's padding. Parameters: gint32 xpad* Required (not null) the x padding of the cell renderer gint32 ypad Required (not null) the y padding of the cell renderer Returns: none	Gtk.CellRenderer
	set_sensitive (gboolean *sensitive) : none Sets the cell renderer's sensitivity. Sets the cell renderer's sensitivity. Parameters: gboolean sensitive* Required (not null) the sensitivity of the cell Returns: none	Gtk.CellRenderer
	set_visible (gboolean *visible) : none Sets the cell renderer's visibility. Sets the cell renderer's visibility. Parameters: gboolean visible* Required (not null) the visibility of the cell Returns: none	Gtk.CellRenderer
	start_editing (Event *event, Widget widget, String path, RectangleInt background_area, RectangleInt cell_area, CellRendererState flags) : Gtk.CellEditable Passes an activate event to the cell renderer for possible processing. Passes an activate event to the cell renderer for possible processing. Parameters: Gdk.Event event* Required (not null) a GdkEvent Gtk.Widget widget Required (not null) widget that received the event String path Required (not null) widget-dependent string representation of the event location; e.g. for GtkTreeView, a string representation of GtkTreePath cairo.RectangleInt background_area Required (not null) background area as passed to gtk_cell_renderer_render() cairo.RectangleInt cell_area Required (not null) cell area as passed to gtk_cell_renderer_render() Gtk.CellRendererState flags Required (not null) render flags Returns: Gtk.CellEditable A new GtkCellEditable, or NULL	Gtk.CellRenderer
	stop_editing (gboolean *canceled) : none Informs the cell renderer that the editing is stopped. Informs the cell renderer that the editing is stopped. If canceled* is TRUE, the cell renderer will emit the GtkCellRenderer::editing-canceled signal. This function should be called by cell renderer implementations in response to the GtkCellEditable::editing-done signal of GtkCellEditable. Parameters: gboolean canceled Required (not null) TRUE if the editing has been canceled Returns: none	Gtk.CellRenderer

Events - usage syntax: this.signals.EVENTNAME.connect( Function )
Event		Defined By
	editing_canceled (CellRenderer *self) : none This signal gets emitted when the user cancels the process of editing a cell. 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. Parameters: Gtk.CellRenderer self* Returns: {none}	Gtk.CellRenderer
	editing_started (CellRenderer *self, CellEditable editable, String path) : none This signal gets emitted when a cell starts to be edited. 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 GtkEntryCompletion* or setting up additional columns in a GtkComboBox. 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); } } ]\| Parameters: Gtk.CellRenderer self* Gtk.CellEditable editable String path Returns: {none}	Gtk.CellRenderer

Used by These Methods / Signals / Properties
Class / Namespace	Method / Signal / Properties
Gtk.CellArea Property	edited_cell : Gtk.CellRenderer read only 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().
Gtk.CellArea Property	focus_cell : Gtk.CellRenderer The cell in the area that currently has focus
Gtk.CellArea Signal	focus_changed (CellArea *self, CellRenderer renderer, String path) : none Indicates that focus changed on this area*.
Gtk.CellArea Signal	remove_editable (CellArea *self, CellRenderer renderer, CellEditable editable) : none Indicates that editing finished on renderer* and that editable should be removed from the owning cell-layouting widget.
Gtk.CellArea Method	activate_cell (Widget *widget, CellRenderer renderer, Event event, RectangleInt cell_area, CellRendererState flags) : gboolean This is used by GtkCellArea* subclasses when handling events to activate cells, the base GtkCellArea class activates cells for keyboard events for free in its own GtkCellArea->activate() implementation.
Gtk.CellArea Method	add (CellRenderer *renderer) : none Adds renderer* to area with the default child cell properties.
Gtk.CellArea Method	add_focus_sibling (CellRenderer *renderer, CellRenderer sibling) : none 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.
Gtk.CellArea Method	attribute_connect (CellRenderer *renderer, String attribute, gint32 column) : none Connects an attribute* to apply values from column for the GtkTreeModel in use.
Gtk.CellArea Method	attribute_disconnect (CellRenderer *renderer, String attribute) : none Disconnects attribute* for the renderer in area so that attribute will no longer be updated with values from the model.
Gtk.CellArea Method	cell_get_property (CellRenderer *renderer, String property_name, Value value) : none Gets the value of a cell property for renderer* in area.
Gtk.CellArea Method	cell_set_property (CellRenderer *renderer, String property_name, Value value) : none Sets a cell property for renderer* in area.
Gtk.CellArea Method	get_cell_allocation (CellAreaContext *context, Widget widget, CellRenderer renderer, RectangleInt cell_area) : cairo.RectangleInt Derives the allocation of renderer* inside area if area were to be renderered in cell_area.
Gtk.CellArea Method	get_cell_at_position (CellAreaContext *context, Widget widget, RectangleInt cell_area, gint32 x, gint32 y, Object out_values) : Gtk.CellRenderer Gets the GtkCellRenderer* at x and y coordinates inside area and optionally returns the full cell allocation for it inside cell_area.
Gtk.CellArea Method	get_edited_cell () : Gtk.CellRenderer Gets the GtkCellRenderer in area that is currently being edited.
Gtk.CellArea Method	get_focus_cell () : Gtk.CellRenderer Retrieves the currently focused cell for area
Gtk.CellArea Method	get_focus_from_sibling (CellRenderer *renderer) : Gtk.CellRenderer Gets the GtkCellRenderer* which is expected to be focusable for which renderer is, or may be a sibling.
Gtk.CellArea Method	get_focus_siblings (CellRenderer *renderer) : Array Gets the focus sibling cell renderers for renderer*.
Gtk.CellArea Method	has_renderer (CellRenderer *renderer) : gboolean Checks if area* contains renderer.
Gtk.CellArea Method	is_focus_sibling (CellRenderer *renderer, CellRenderer sibling) : gboolean Returns whether sibling* is one of renderer's focus siblings (see gtk_cell_area_add_focus_sibling()).
Gtk.CellArea Method	remove (CellRenderer *renderer) : none Removes renderer* from area.
Gtk.CellArea Method	remove_focus_sibling (CellRenderer *renderer, CellRenderer sibling) : none Removes sibling* from renderer's focus sibling list (see gtk_cell_area_add_focus_sibling()).
Gtk.CellArea Method	request_renderer (CellRenderer *renderer, Orientation orientation, Widget widget, gint32 for_size) : Object This is a convenience function for GtkCellArea* implementations to request size for cell renderers.
Gtk.CellArea Method	set_focus_cell (CellRenderer *renderer) : none Explicitly sets the currently focused cell to renderer*.
Gtk.CellAreaBox Method	pack_end (CellRenderer *renderer, gboolean expand, gboolean align, gboolean fixed) : none Adds renderer* to box, packed with reference to the end of box.
Gtk.CellAreaBox Method	pack_start (CellRenderer *renderer, gboolean expand, gboolean align, gboolean fixed) : none Adds renderer* to box, packed with reference to the start of box.
Gtk.CellLayout Method	add_attribute (CellRenderer *cell, String attribute, gint32 column) : none Adds an attribute mapping to the list in cell_layout*.
Gtk.CellLayout Method	clear_attributes (CellRenderer *cell*) : none Clears all existing attributes previously set with gtk_cell_layout_set_attributes().
Gtk.CellLayout Method	pack_end (CellRenderer *cell, gboolean expand) : none Adds the cell* to the end of cell_layout.
Gtk.CellLayout Method	pack_start (CellRenderer *cell, gboolean expand) : none Packs the cell* into the beginning of cell_layout.
Gtk.CellLayout Method	reorder (CellRenderer *cell, gint32 position) : none Re-inserts cell* at position.
Gtk.CellLayout Method	set_cell_data_func (CellRenderer *cell, Function func, void *func_data, Function destroy) : none Sets the GtkCellLayoutDataFunc* to use for cell_layout.
Gtk.IconView Method	set_cursor (TreePath *path, CellRenderer cell, gboolean start_editing) : none Sets the current keyboard focus to be at path*, and selects it.
Gtk.IconView Method	set_tooltip_cell (Tooltip *tooltip, TreePath path, CellRenderer cell) : none Sets the tip area of tooltip* to the area which cell occupies in the item pointed to by path.
Gtk.TreeView Method	insert_column_with_data_func (gint32 *position, String title, CellRenderer cell, Function func, void *data, Function dnotify) : gint32 Convenience function that inserts a new column into the GtkTreeView* with the given cell renderer and a GtkCellDataFunc to set cell renderer attributes (normally using data from the model).
Gtk.TreeView Method	set_cursor_on_cell (TreePath *path, TreeViewColumn focus_column, CellRenderer focus_cell, gboolean start_editing) : none Sets the current keyboard focus to be at path*, and selects it.
Gtk.TreeView Method	set_tooltip_cell (Tooltip *tooltip, TreePath path, TreeViewColumn column, CellRenderer cell) : none Sets the tip area of tooltip* to the area path, column and cell have in common.
Gtk.TreeViewColumn Method	add_attribute (CellRenderer *cell_renderer, String attribute, gint32 column) : none Adds an attribute mapping to the list in tree_column*.
Gtk.TreeViewColumn Method	cell_get_position (CellRenderer *cell_renderer, Object out_values*) : gboolean Obtains the horizontal position and size of a cell in a column.
Gtk.TreeViewColumn Method	clear_attributes (CellRenderer *cell_renderer*) : none Clears all existing attributes previously set with gtk_tree_view_column_set_attributes().
Gtk.TreeViewColumn Method	focus_cell (CellRenderer *cell) : none Sets the current keyboard focus to be at cell*, if the column contains 2 or more editable and activatable cells.
Gtk.TreeViewColumn Method	pack_end (CellRenderer *cell, gboolean expand) : none Adds the cell* to end of the column.
Gtk.TreeViewColumn Method	pack_start (CellRenderer *cell, gboolean expand) : none Packs the cell* into the beginning of the column.
Gtk.TreeViewColumn Method	set_cell_data_func (CellRenderer *cell_renderer, Function func, void *func_data, Function destroy) : none Sets the GtkTreeViewColumnFunc* to use for the column.