gtk.cell_renderer

Module for [CellRenderer] class

class CellRenderer CellRendererGidBuilder CellRendererGidBuilderImpl

Types 3

classCellRenderer : gobject.initially_unowned.InitiallyUnowned

An object for rendering a single cell

The [gtk.cell_renderer.CellRenderer] is a base class of a set of objects used for rendering a cell to a [cairo.context.Context]. These objects are used primarily by the [gtk.tree_view.TreeView] widget, though they aren’t tied to them in any specific way. It is worth noting that [gtk.cell_renderer.CellRenderer] is not a [gtk.widget.Widget] and cannot be treated as such.

The primary use of a [gtk.cell_renderer.CellRenderer] is for drawing a certain graphical elements on a [cairo.context.Context]. 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 [gobject.object.ObjectWrap]s property system. Then, the cell is measured using [gtk.cell_renderer.CellRenderer.getPreferredSize]. Finally, the cell is rendered in the correct location using [gtk.cell_renderer.CellRenderer.snapshot].

There are a number of rules that must be followed when writing a new [gtk.cell_renderer.CellRenderer]. First and foremost, it’s important that a certain set of properties will always yield a cell renderer of the same size, barring a style change. The [gtk.cell_renderer.CellRenderer] 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.CellRenderer]Toggle, which toggles when it gets activated by a mouse click, or it can be “editable” like [gtk.cell_renderer.CellRenderer]Text, which allows the user to edit the text using a widget implementing the [gtk.cell_editable.CellEditable] interface, e.g. [gtk.entry.Entry]. To make a cell renderer activatable or editable, you have to implement the [gtk.cell_renderer.CellRenderer]Class.activate or [gtk.cell_renderer.CellRenderer]Class.start_editing virtual functions, respectively.

Many properties of [gtk.cell_renderer.CellRenderer] 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.

Deprecated

List views use widgets for displaying their

contents

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.rgba.RGBA cellBackgroundRgba() @propertyGet `cellBackgroundRgba` property. Returns: Cell background as a [gdk.rgba.RGBA]

void cellBackgroundRgba(gdk.rgba.RGBA propval) @propertySet `cellBackgroundRgba` property. Params: propval = Cell background as a [gdk.rgba.RGBA]

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, [gtk.cellrenderertoggle.CellRendererToggle] 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.

bool getIsExpanded()Checks whether the given [gtk.cell_renderer.CellRenderer] is expanded. Returns: true if the cell renderer is expanded

bool getIsExpander()Checks whether the given [gtk.cell_renderer.CellRenderer] is an expander. Returns: true if cell is an expander, and false otherwise

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)Retrieves a renderer’s natural size when rendered to widget.

void getPreferredHeightForWidth(gtk.widget.Widget widget,  int  width,  out  int  minimumHeight,  out  int  naturalHeight)

Retrieves 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)Retrieves a renderer’s natural size when rendered to widget.

void getPreferredWidthForHeight(gtk.widget.Widget widget,  int  height,  out  int  minimumWidth,  out  int  naturalWidth)

Retrieves 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 [gtk.types.SizeRequestMode] preferred by this renderer.

bool getSensitive()Returns the cell renderer’s sensitivity. Returns: true if the cell renderer is sensitive

gtk.types.StateFlags getState(gtk.widget.Widget widget, gtk.types.CellRendererState cellState)Translates the cell renderer state to [gtk.types.StateFlags], based on the cell renderer and widget sensitivity, and the given [gtk.cell_renderer.CellRenderer]State.

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 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 setIsExpanded(bool isExpanded)Sets whether the given [gtk.cell_renderer.CellRenderer] is expanded.

void setIsExpander(bool isExpander)Sets whether the given [gtk.cell_renderer.CellRenderer] is an expander.

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.

void snapshot(gtk.snapshot.Snapshot snapshot,  gtk.widget.Widget widget,  gdk.rectangle.Rectangle backgroundArea,  gdk.rectangle.Rectangle cellArea,  gtk.types.CellRendererState flags)

Invokes the virtual render function of the [gtk.cellrenderer.CellRenderer]. The three passed-in rectangles are areas in cr. Most renderers will draw within cellarea; the xalign, yalign, xpad, and y...

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 [gtk.celleditable.CellEditable] widget created by the [gtk.cellrenderer.CellRenderer]Class.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 [gtk.cell_renderer.CellRenderer]::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 cellBackgroundRgba(gdk.rgba.RGBA propval)Set `cellBackgroundRgba` property. Params: propval = Cell background as a [gdk.rgba.RGBA] 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()