gtk.cell_renderer

Module for [CellRenderer] class

class CellRenderer CellRendererGidBuilder CellRendererGidBuilderImpl

Types 3

classCellRenderer : gobject.initially_unowned.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.CellRenderer.getSize]. Finally, the cell is rendered in the correct location using [gtk.cell_renderer.CellRenderer.render].

There are a number of rules that must be followed when writing a new #GtkCellRenderer. First and foremost, it’s 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 widget implementing the #GtkCellEditable interface, e.g. #GtkEntry. To make a cell renderer activatable or editable, you have to implement the #GtkCellRendererClass.activate or #GtkCellRendererClass.start_editing virtual functions, respectively.

Many properties of #GtkCellRenderer 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.

Methods
GType _getGType()
GType _gType() @property
CellRenderer self()Returns `this`, for use in `with` statements.
CellRendererGidBuilder builder()Get builder for [gtk.cell_renderer.CellRenderer] Returns: New builder object
void cellBackground(string propval) @property
gdk.color.Color cellBackgroundGdk() @propertyGet `cellBackgroundGdk` property. Returns: Cell background as a #GdkColor
void cellBackgroundGdk(gdk.color.Color propval) @propertySet `cellBackgroundGdk` property. Params: propval = Cell background as a #GdkColor
gdk.rgba.RGBA cellBackgroundRgba() @propertyGet `cellBackgroundRgba` property. Returns: Cell background as a #GdkRGBA
void cellBackgroundRgba(gdk.rgba.RGBA propval) @propertySet `cellBackgroundRgba` property. Params: propval = Cell background as a #GdkRGBA
bool cellBackgroundSet() @property
void cellBackgroundSet(bool propval) @property
bool editing() @property
int height() @property
void height(int propval) @property
bool isExpanded() @property
void isExpanded(bool propval) @property
bool isExpander() @property
void isExpander(bool propval) @property
gtk.types.CellRendererMode mode() @property
void mode(gtk.types.CellRendererMode propval) @property
bool sensitive() @property
void sensitive(bool propval) @property
bool visible() @property
void visible(bool propval) @property
int width() @property
void width(int propval) @property
float xalign() @property
void xalign(float propval) @property
uint xpad() @property
void xpad(uint propval) @property
float yalign() @property
void yalign(float propval) @property
uint ypad() @property
void ypad(uint propval) @property
bool activate(gdk.event.Event event, gtk.widget.Widget widget, string path, gdk.rectangle.Rectangle backgroundArea, gdk.rectangle.Rectangle cellArea, gtk.types.CellRendererState flags)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.
void getAlignedArea(gtk.widget.Widget widget, gtk.types.CellRendererState flags, gdk.rectangle.Rectangle cellArea, out gdk.rectangle.Rectangle alignedArea)Gets the aligned area used by cell inside cell_area. Used for finding the appropriate edit and focus rectangle.
void getAlignment(out float xalign, out float yalign)Fills in xalign and yalign with the appropriate values of cell.
void getFixedSize(out int width, out int height)Fills in width and height with the appropriate size of cell.
void getPadding(out int xpad, out int ypad)Fills in xpad and ypad with the appropriate values of cell.
void getPreferredHeight(gtk.widget.Widget widget, out int minimumSize, out int naturalSize)Retreives a renderer’s natural size when rendered to widget.
void getPreferredHeightForWidth(gtk.widget.Widget widget, int width, out int minimumHeight, out int naturalHeight)Retreives a cell renderers’s minimum and natural height if it were rendered to widget with the specified width.
void getPreferredSize(gtk.widget.Widget widget, out gtk.requisition.Requisition minimumSize, out gtk.requisition.Requisition naturalSize)Retrieves the minimum and natural size of a cell taking into account the widget’s preference for height-for-width management.
void getPreferredWidth(gtk.widget.Widget widget, out int minimumSize, out int naturalSize)Retreives a renderer’s natural size when rendered to widget.
void getPreferredWidthForHeight(gtk.widget.Widget widget, int height, out int minimumWidth, out int naturalWidth)Retreives a cell renderers’s minimum and natural width if it were rendered to widget with the specified height.
gtk.types.SizeRequestMode getRequestMode()Gets whether the cell renderer prefers a height-for-width layout or a width-for-height layout. Returns: The #GtkSizeRequestMode preferred by this renderer.
bool getSensitive()Returns the cell renderer’s sensitivity. Returns: true if the cell renderer is sensitive
void getSize(gtk.widget.Widget widget, gdk.rectangle.Rectangle cellArea, out int xOffset, out int yOffset, out int width, out int height)Obtains the width and height needed to render the cell. Used by view widgets to determine the appropriate size for the cellarea passed to [gtk.cellrenderer.CellRenderer.render]. If cell_area is no...
gtk.types.StateFlags getState(gtk.widget.Widget widget, gtk.types.CellRendererState cellState)Translates the cell renderer state to #GtkStateFlags, based on the cell renderer and widget sensitivity, and the given #GtkCellRendererState.
bool getVisible()Returns the cell renderer’s visibility. Returns: true if the cell renderer is visible
bool isActivatable()Checks whether the cell renderer can do something when activated. Returns: true if the cell renderer can do anything when activated
void render(cairo.context.Context cr, gtk.widget.Widget widget, gdk.rectangle.Rectangle backgroundArea, gdk.rectangle.Rectangle cellArea, gtk.types.CellRendererState flags)Invokes the virtual render function of the #GtkCellRenderer. The three passed-in rectangles are areas in cr. Most renderers will draw within cellarea; the xalign, yalign, xpad, and ypad fields of t...
void setAlignment(float xalign, float yalign)Sets the renderer’s alignment within its available space.
void setFixedSize(int width, int height)Sets the renderer size to be explicit, independent of the properties set.
void setPadding(int xpad, int ypad)Sets the renderer’s padding.
void setSensitive(bool sensitive)Sets the cell renderer’s sensitivity.
void setVisible(bool visible)Sets the cell renderer’s visibility.
gtk.cell_editable.CellEditable startEditing(gdk.event.Event event, gtk.widget.Widget widget, string path, gdk.rectangle.Rectangle backgroundArea, gdk.rectangle.Rectangle cellArea, gtk.types.CellRendererState flags)Starts editing the contents of this cell, through a new #GtkCellEditable widget created by the #GtkCellRendererClass.start_editing virtual function.
void stopEditing(bool canceled)Informs the cell renderer that the editing is stopped. If canceled is true, the cell renderer will emit the #GtkCellRenderer::editing-canceled signal.
gulong connectEditingCanceled(T)(T callback, Flag!"After" after = No.After) if (isCallable!T && is(ReturnType!T == void) && (Parameters!T.length < 1 || (ParameterStorageClassTuple!T[0] == ParameterStorageClass.none && is(Parameters!T[0] : gtk.cell_renderer.CellRenderer))) && Parameters!T.length < 2)Connect to `EditingCanceled` signal.
gulong connectEditingStarted(T)(T callback, Flag!"After" after = No.After) if (isCallable!T && is(ReturnType!T == void) && (Parameters!T.length < 1 || (ParameterStorageClassTuple!T[0] == ParameterStorageClass.none && is(Parameters!T[0] : gtk.cell_editable.CellEditable))) && (Parameters!T.length < 2 || (ParameterStorageClassTuple!T[1] == ParameterStorageClass.none && is(Parameters!T[1] == string))) && (Parameters!T.length < 3 || (ParameterStorageClassTuple!T[2] == ParameterStorageClass.none && is(Parameters!T[2] : gtk.cell_renderer.CellRenderer))) && Parameters!T.length < 4)Connect to `EditingStarted` signal.
Constructors
this(void * ptr, Flag!"Take" take)
classCellRendererGidBuilderImpl(T) : gobject.initially_unowned.InitiallyUnownedGidBuilderImpl!T
Methods
T cellBackground(string propval)
T cellBackgroundGdk(gdk.color.Color propval)Set `cellBackgroundGdk` property. Params: propval = Cell background as a #GdkColor Returns: Builder instance for fluent chaining
T cellBackgroundRgba(gdk.rgba.RGBA propval)Set `cellBackgroundRgba` property. Params: propval = Cell background as a #GdkRGBA Returns: Builder instance for fluent chaining
T cellBackgroundSet(bool propval)
T height(int propval)
T isExpanded(bool propval)
T isExpander(bool propval)
T mode(gtk.types.CellRendererMode propval)
T sensitive(bool propval)
T visible(bool propval)
T width(int propval)
T xalign(float propval)
T xpad(uint propval)
T yalign(float propval)
T ypad(uint propval)
classCellRendererGidBuilder : CellRendererGidBuilderImpl!CellRendererGidBuilder

Fluent builder for [gtk.cell_renderer.CellRenderer]

Methods
CellRenderer build()