Back to Seed Clases

Gtk

Classes

Interfaces

Structs

Unions

Enums

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

Class Gtk.CellRendererText

Import line:	Gtk = imports.gi.Gtk;
GIR File:	Gtk-3.0.gir
C documentation:	GtkCellRendererText
Class :	CellRendererText
Subclasses:	Gtk.CellRendererAccel, Gtk.CellRendererCombo, Gtk.CellRendererSpin
Extends:	Gtk.CellRenderer

A GtkCellRendererText renders a given text in its cell, using the font, color and
style information provided by its properties. The text will be ellipsized if it is
too long and the GtkCellRendererText:ellipsize property allows it.
If the GtkCellRenderer:mode is GTK_CELL_RENDERER_MODE_EDITABLE,
the GtkCellRendererText allows to edit its text using an entry.

Properties
Properties		Defined By
	align_set : gboolean	Gtk.CellRendererText
	alignment : Pango.Alignment Specifies how to align the lines of text with respect to each other. Specifies how to align the lines of text with respect to each other. Note that this property describes how to align the lines of text in case there are several of them. The "xalign" property of GtkCellRenderer, on the other hand, sets the horizontal alignment of the whole text.	Gtk.CellRendererText
	attributes : Pango.AttrList	Gtk.CellRendererText
	background : String	Gtk.CellRendererText
	background_gdk : Gdk.Color	Gtk.CellRendererText
	background_rgba : Gdk.RGBA Background color as a GdkRGBA Background color as a GdkRGBA	Gtk.CellRendererText
	background_set : gboolean	Gtk.CellRendererText
	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
	editable : gboolean	Gtk.CellRendererText
	editable_set : gboolean	Gtk.CellRendererText
	editing : gboolean read only	Gtk.CellRenderer
	ellipsize : Pango.EllipsizeMode Specifies the preferred place to ellipsize the string, if the cell renderer does not have enough room to display the entire string. Specifies the preferred place to ellipsize the string, if the cell renderer does not have enough room to display the entire string. Setting it to PANGO_ELLIPSIZE_NONE turns off ellipsizing. See the wrap-width property for another way of making the text fit into a given width.	Gtk.CellRendererText
	ellipsize_set : gboolean	Gtk.CellRendererText
	family : String	Gtk.CellRendererText
	family_set : gboolean	Gtk.CellRendererText
	font : String	Gtk.CellRendererText
	font_desc : Pango.FontDescription	Gtk.CellRendererText
	foreground : String	Gtk.CellRendererText
	foreground_gdk : Gdk.Color	Gtk.CellRendererText
	foreground_rgba : Gdk.RGBA Foreground color as a GdkRGBA Foreground color as a GdkRGBA	Gtk.CellRendererText
	foreground_set : gboolean	Gtk.CellRendererText
	g_type_instance : GObject.TypeInstance	GObject.InitiallyUnowned
	height : gint32	Gtk.CellRenderer
	is_expanded : gboolean	Gtk.CellRenderer
	is_expander : gboolean	Gtk.CellRenderer
	language : String	Gtk.CellRendererText
	language_set : gboolean	Gtk.CellRendererText
	markup : String	Gtk.CellRendererText
	max_width_chars : gint32 The desired maximum width of the cell, in characters. The desired maximum width of the cell, in characters. If this property is set to -1, the width will be calculated automatically. For cell renderers that ellipsize or wrap text; this property controls the maximum reported width of the cell. The cell should not receive any greater allocation unless it is set to expand in its GtkCellLayout and all of the cell's siblings have received their natural width.	Gtk.CellRendererText
	mode : Gtk.CellRendererMode	Gtk.CellRenderer
	parent : Gtk.CellRenderer read only	Gtk.CellRendererText
	parent_instance : GObject.InitiallyUnowned read only	Gtk.CellRenderer
	priv : Gtk.CellRendererTextPrivate read only	Gtk.CellRendererText
	qdata : GLib.Data read only	GObject.InitiallyUnowned
	ref_count : guint32 read only	GObject.InitiallyUnowned
	rise : gint32	Gtk.CellRendererText
	rise_set : gboolean	Gtk.CellRendererText
	scale : gdouble	Gtk.CellRendererText
	scale_set : gboolean	Gtk.CellRendererText
	sensitive : gboolean	Gtk.CellRenderer
	single_paragraph_mode : gboolean	Gtk.CellRendererText
	size : gint32	Gtk.CellRendererText
	size_points : gdouble	Gtk.CellRendererText
	size_set : gboolean	Gtk.CellRendererText
	stretch : Pango.Stretch	Gtk.CellRendererText
	stretch_set : gboolean	Gtk.CellRendererText
	strikethrough : gboolean	Gtk.CellRendererText
	strikethrough_set : gboolean	Gtk.CellRendererText
	style : Pango.Style	Gtk.CellRendererText
	style_set : gboolean	Gtk.CellRendererText
	text : String	Gtk.CellRendererText
	underline : Pango.Underline	Gtk.CellRendererText
	underline_set : gboolean	Gtk.CellRendererText
	variant : Pango.Variant	Gtk.CellRendererText
	variant_set : gboolean	Gtk.CellRendererText
	visible : gboolean	Gtk.CellRenderer
	weight : gint32	Gtk.CellRendererText
	weight_set : gboolean	Gtk.CellRendererText
	width : gint32	Gtk.CellRenderer
	width_chars : gint32 The desired width of the cell, in characters. The desired width of the cell, in characters. If this property is set to -1, the width will be calculated automatically, otherwise the cell will request either 3 characters or the property value, whichever is greater.	Gtk.CellRendererText
	wrap_mode : Pango.WrapMode Specifies how to break the string into multiple lines, if the cell renderer does not have enough room to display the entire string. Specifies how to break the string into multiple lines, if the cell renderer does not have enough room to display the entire string. This property has no effect unless the wrap-width property is set.	Gtk.CellRendererText
	wrap_width : gint32 Specifies the minimum width at which the text is wrapped. Specifies the minimum width at which the text is wrapped. The wrap-mode property can be used to influence at what character positions the line breaks can be placed. Setting wrap-width to -1 turns wrapping off.	Gtk.CellRendererText
	xalign : gfloat	Gtk.CellRenderer
	xpad : guint32	Gtk.CellRenderer
	yalign : gfloat	Gtk.CellRenderer
	ypad : guint32	Gtk.CellRenderer

Methods / Constructors
Method / Constructor		Defined By
	new Gtk.CellRendererText (Object *properties) Create a new Gtk.CellRendererText Create a new Gtk.CellRendererText 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_height_from_font (gint32 *number_of_rows) : none Sets the height of a renderer to explicitly be determined by the "font" and "y_pad" property set on it. Sets the height of a renderer to explicitly be determined by the "font" and "y_pad" property set on it. Further changes in these properties do not affect the height, so they must be accompanied by a subsequent call to this function. Using this function is unflexible, and should really only be used if calculating the size of a cell is too slow (ie, a massive number of cells displayed). If number_of_rows* is -1, then the fixed height is unset, and the height is determined by the properties again. Parameters: gint32 number_of_rows Required (not null) Number of rows of text each cell renderer is allocated, or -1 Returns: none	Gtk.CellRendererText
	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
	edited (CellRendererText *self, String path, String new_text) : none This signal is emitted after renderer* has been edited. This signal is emitted after renderer has been edited. It is the responsibility of the application to update the model and store new_text at the position indicated by path. Parameters: Gtk.CellRendererText self String path String new_text Returns: {none}	Gtk.CellRendererText
	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