gtk_cell_renderer_get_size ()

void
gtk_cell_renderer_get_size (GtkCellRenderer *cell,
                            GtkWidget *widget,
                            const GdkRectangle *cell_area,
                            gint *x_offset,
                            gint *y_offset,
                            gint *width,
                            gint *height);

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.

gtk_cell_renderer_render ()

void
gtk_cell_renderer_render (GtkCellRenderer *cell,
                          GdkWindow *window,
                          GtkWidget *widget,
                          const GdkRectangle *background_area,
                          const GdkRectangle *cell_area,
                          const GdkRectangle *expose_area,
                          GtkCellRendererState flags);

Invokes the virtual render function of the GtkCellRenderer. The three passed-in rectangles are areas of window . Most renderers will draw within cell_area ; the xalign, yalign, xpad, and ypad fields of the GtkCellRenderer 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 window . expose_area is a clip rectangle.

gtk_cell_renderer_activate ()

gboolean
gtk_cell_renderer_activate (GtkCellRenderer *cell,
                            GdkEvent *event,
                            GtkWidget *widget,
                            const gchar *path,
                            const GdkRectangle *background_area,
                            const GdkRectangle *cell_area,
                            GtkCellRendererState 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.

gtk_cell_renderer_start_editing ()

GtkCellEditable *
gtk_cell_renderer_start_editing (GtkCellRenderer *cell,
                                 GdkEvent *event,
                                 GtkWidget *widget,
                                 const gchar *path,
                                 const GdkRectangle *background_area,
                                 const GdkRectangle *cell_area,
                                 GtkCellRendererState flags);

Passes an activate event to the cell renderer for possible processing.

gtk_cell_renderer_editing_canceled ()

void
gtk_cell_renderer_editing_canceled (GtkCellRenderer *cell);

Causes the cell renderer to emit the “editing-canceled” signal.

This function is for use only by implementations of cell renderers that need to notify the client program that an editing process was canceled and the changes were not committed.

Since 2.4

gtk_cell_renderer_stop_editing ()

void
gtk_cell_renderer_stop_editing (GtkCellRenderer *cell,
                                gboolean canceled);

Informs the cell renderer that the editing is stopped. If canceled is TRUE, the cell renderer will emit the “editing-canceled” signal.

This function should be called by cell renderer implementations in response to the “editing-done” signal of GtkCellEditable.

Since 2.6

gtk_cell_renderer_get_fixed_size ()

void
gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell,
                                  gint *width,
                                  gint *height);

Fills in width and height with the appropriate size of cell .

gtk_cell_renderer_set_fixed_size ()

void
gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell,
                                  gint width,
                                  gint height);

Sets the renderer size to be explicit, independent of the properties set.

gtk_cell_renderer_get_visible ()

gboolean
gtk_cell_renderer_get_visible (GtkCellRenderer *cell);

Returns the cell renderer's visibility.

Since 2.18

gtk_cell_renderer_set_visible ()

void
gtk_cell_renderer_set_visible (GtkCellRenderer *cell,
                               gboolean visible);

Sets the cell renderer's visibility.

Since 2.18

gtk_cell_renderer_get_sensitive ()

gboolean
gtk_cell_renderer_get_sensitive (GtkCellRenderer *cell);

Returns the cell renderer's sensitivity.

Since 2.18

gtk_cell_renderer_set_sensitive ()

void
gtk_cell_renderer_set_sensitive (GtkCellRenderer *cell,
                                 gboolean sensitive);

Sets the cell renderer's sensitivity.

Since 2.18

gtk_cell_renderer_get_alignment ()

void
gtk_cell_renderer_get_alignment (GtkCellRenderer *cell,
                                 gfloat *xalign,
                                 gfloat *yalign);

Fills in xalign and yalign with the appropriate values of cell .

Since 2.18

gtk_cell_renderer_set_alignment ()

void
gtk_cell_renderer_set_alignment (GtkCellRenderer *cell,
                                 gfloat xalign,
                                 gfloat yalign);

Sets the renderer's alignment within its available space.

Since 2.18

gtk_cell_renderer_get_padding ()

void
gtk_cell_renderer_get_padding (GtkCellRenderer *cell,
                               gint *xpad,
                               gint *ypad);

Fills in xpad and ypad with the appropriate values of cell .

Since 2.18

gtk_cell_renderer_set_padding ()

void
gtk_cell_renderer_set_padding (GtkCellRenderer *cell,
                               gint xpad,
                               gint ypad);

Sets the renderer's padding.

Since 2.18

enum GtkCellRendererState

Tells how a cell is to be rendererd.

enum GtkCellRendererMode

Identifies how the user can interact with a particular cell.

struct GtkCellRenderer

struct GtkCellRenderer;

struct GtkCellRendererClass

struct GtkCellRendererClass {
  GtkObjectClass parent_class;

  /* vtable - not signals */
  void             (* get_size)      (GtkCellRenderer      *cell,
				      GtkWidget            *widget,
				      GdkRectangle         *cell_area,
				      gint                 *x_offset,
				      gint                 *y_offset,
				      gint                 *width,
				      gint                 *height);
  void             (* render)        (GtkCellRenderer      *cell,
				      GdkDrawable          *window,
				      GtkWidget            *widget,
				      GdkRectangle         *background_area,
				      GdkRectangle         *cell_area,
				      GdkRectangle         *expose_area,
				      GtkCellRendererState  flags);
  gboolean         (* activate)      (GtkCellRenderer      *cell,
				      GdkEvent             *event,
				      GtkWidget            *widget,
				      const gchar          *path,
				      GdkRectangle         *background_area,
				      GdkRectangle         *cell_area,
				      GtkCellRendererState  flags);
  GtkCellEditable *(* start_editing) (GtkCellRenderer      *cell,
				      GdkEvent             *event,
				      GtkWidget            *widget,
				      const gchar          *path,
				      GdkRectangle         *background_area,
				      GdkRectangle         *cell_area,
				      GtkCellRendererState  flags);

  /* Signals */
  void (* editing_canceled) (GtkCellRenderer *cell);
  void (* editing_started)  (GtkCellRenderer *cell,
			     GtkCellEditable *editable,
			     const gchar     *path);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
};

The “cell-background” property

  “cell-background”          gchar *

Cell background color as a string.

Flags: Write

Default value: NULL

The “cell-background-gdk” property

  “cell-background-gdk”      GdkColor *

Cell background color as a GdkColor.

Flags: Read / Write

The “cell-background-set” property

  “cell-background-set”      gboolean

Whether this tag affects the cell background color.

Flags: Read / Write

Default value: FALSE

The “editing” property

  “editing”                  gboolean

Whether the cell renderer is currently in editing mode.

Flags: Read

Default value: FALSE

The “height” property

  “height”                   gint

The fixed height.

Flags: Read / Write

Allowed values: >= -1

Default value: -1

The “is-expanded” property

  “is-expanded”              gboolean

Row is an expander row, and is expanded.

Flags: Read / Write

Default value: FALSE

The “is-expander” property

  “is-expander”              gboolean

Row has children.

Flags: Read / Write

Default value: FALSE

The “mode” property

  “mode”                     GtkCellRendererMode

Editable mode of the CellRenderer.

Flags: Read / Write

Default value: GTK_CELL_RENDERER_MODE_INERT

The “sensitive” property

  “sensitive”                gboolean

Display the cell sensitive.

Flags: Read / Write

Default value: TRUE

The “visible” property

  “visible”                  gboolean

Display the cell.

Flags: Read / Write

Default value: TRUE

The “width” property

  “width”                    gint

The fixed width.

Flags: Read / Write

Allowed values: >= -1

Default value: -1

The “xalign” property

  “xalign”                   gfloat

The x-align.

Flags: Read / Write

Allowed values: [0,1]

Default value: 0.5

The “xpad” property

  “xpad”                     guint

The xpad.

Flags: Read / Write

Default value: 0

The “yalign” property

  “yalign”                   gfloat

The y-align.

Flags: Read / Write

Allowed values: [0,1]

Default value: 0.5

The “ypad” property

  “ypad”                     guint

The ypad.

Flags: Read / Write

Default value: 0

The “editing-canceled” signal

void
user_function (GtkCellRenderer *renderer,
               gpointer         user_data)

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.

See also: gtk_cell_renderer_stop_editing().

Flags: Run First

Since 2.4

The “editing-started” signal

void
user_function (GtkCellRenderer *renderer,
               GtkCellEditable *editable,
               gchar           *path,
               gpointer         user_data)

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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);
    }
}

Flags: Run First

Since 2.6