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() static nothrow

GType _gType() @property nothrow

CellRenderer self() nothrowReturns `this`, for use in `with` statements.

CellRendererGidBuilder builder() static nothrowGet builder for [gtk.cell_renderer.CellRenderer] Returns: New builder object

void cellBackground(string propval) @property nothrow

gdk.color.Color cellBackgroundGdk() @property nothrowGet `cellBackgroundGdk` property. Returns: Cell background as a #GdkColor

void cellBackgroundGdk(gdk.color.Color propval) @property nothrowSet `cellBackgroundGdk` property. Params: propval = Cell background as a #GdkColor

gdk.rgba.RGBA cellBackgroundRgba() @property nothrowGet `cellBackgroundRgba` property. Returns: Cell background as a #GdkRGBA

void cellBackgroundRgba(gdk.rgba.RGBA propval) @property nothrowSet `cellBackgroundRgba` property. Params: propval = Cell background as a #GdkRGBA

bool cellBackgroundSet() @property nothrow

void cellBackgroundSet(bool propval) @property nothrow

bool editing() @property nothrow

int height() @property nothrow

void height(int propval) @property nothrow

bool isExpanded() @property nothrow

void isExpanded(bool propval) @property nothrow

bool isExpander() @property nothrow

void isExpander(bool propval) @property nothrow

gtk.types.CellRendererMode mode() @property nothrow

void mode(gtk.types.CellRendererMode propval) @property nothrow

bool sensitive() @property nothrow

void sensitive(bool propval) @property nothrow

bool visible() @property nothrow

void visible(bool propval) @property nothrow

int width() @property nothrow

void width(int propval) @property nothrow

float xalign() @property nothrow

void xalign(float propval) @property nothrow

uint xpad() @property nothrow

void xpad(uint propval) @property nothrow

float yalign() @property nothrow

void yalign(float propval) @property nothrow

uint ypad() @property nothrow

void ypad(uint propval) @property nothrow

bool activate(gdk.event.Event event,  gtk.widget.Widget widget,  string path,  gdk.rectangle.Rectangle backgroundArea,  gdk.rectangle.Rectangle cellArea,  gtk.types.CellRendererState flags)

nothrowPasses 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)

nothrowGets 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) nothrowFills in xalign and yalign with the appropriate values of cell.

void getFixedSize(out int width, out int height) nothrowFills in width and height with the appropriate size of cell.

void getPadding(out int xpad, out int ypad) nothrowFills in xpad and ypad with the appropriate values of cell.

void getPreferredHeight(gtk.widget.Widget widget, out int minimumSize, out int naturalSize) nothrowRetreives a renderer’s natural size when rendered to widget.

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

nothrowRetreives 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)

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

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

nothrowRetreives a cell renderers’s minimum and natural width if it were rendered to widget with the specified height.

gtk.types.SizeRequestMode getRequestMode() nothrowGets 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() nothrowReturns 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)

nothrowObtains 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.CellRenderer.render]. If cell_area is ...

gtk.types.StateFlags getState(gtk.widget.Widget widget, gtk.types.CellRendererState cellState) nothrowTranslates the cell renderer state to #GtkStateFlags, based on the cell renderer and widget sensitivity, and the given #GtkCellRendererState.

bool getVisible() nothrowReturns the cell renderer’s visibility. Returns: true if the cell renderer is visible

bool isActivatable() nothrowChecks 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)

nothrowInvokes the virtual render function of the #GtkCellRenderer. The three passed-in rectangles are areas in cr. Most renderers will draw within cell_area; the xalign, yalign, xpad, and ypad fields of ...

void setAlignment(float xalign, float yalign) nothrowSets the renderer’s alignment within its available space.

void setFixedSize(int width, int height) nothrowSets the renderer size to be explicit, independent of the properties set.

void setPadding(int xpad, int ypad) nothrowSets the renderer’s padding.

void setSensitive(bool sensitive) nothrowSets the cell renderer’s sensitivity.

void setVisible(bool visible) nothrowSets 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)

nothrowStarts editing the contents of this cell, through a new #GtkCellEditable widget created by the #GtkCellRendererClass.start_editing virtual function.

void stopEditing(bool canceled) nothrowInforms 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)

nothrowConnect 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)

nothrowConnect to `EditingStarted` signal.

Constructors

this(void * ptr, Flag!"Take" take)

classCellRendererGidBuilderImpl(T) : gobject.initially_unowned.InitiallyUnownedGidBuilderImpl!T

Fluent builder implementation template for gtk.cell_renderer.CellRenderer

Methods

T cellBackground(string propval) nothrow

T cellBackgroundGdk(gdk.color.Color propval) nothrowSet `cellBackgroundGdk` property. Params: propval = Cell background as a #GdkColor Returns: Builder instance for fluent chaining

T cellBackgroundRgba(gdk.rgba.RGBA propval) nothrowSet `cellBackgroundRgba` property. Params: propval = Cell background as a #GdkRGBA Returns: Builder instance for fluent chaining

T cellBackgroundSet(bool propval) nothrow

T height(int propval) nothrow

T isExpanded(bool propval) nothrow

T isExpander(bool propval) nothrow

T mode(gtk.types.CellRendererMode propval) nothrow

T sensitive(bool propval) nothrow

T visible(bool propval) nothrow

T width(int propval) nothrow

T xalign(float propval) nothrow

T xpad(uint propval) nothrow

T yalign(float propval) nothrow

T ypad(uint propval) nothrow

classCellRendererGidBuilder : CellRendererGidBuilderImpl!CellRendererGidBuilder

Fluent builder for gtk.cell_renderer.CellRenderer

Methods

CellRenderer build() nothrowCreate object from builder. Returns: New object