2000-10-05 01:04:57 +00:00
|
|
|
|
/* gtkcellrenderer.c
|
|
|
|
|
* Copyright (C) 2000 Red Hat, Inc. Jonathan Blandford
|
|
|
|
|
*
|
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU Library General Public
|
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
|
* Library General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU Library General Public
|
2012-02-27 13:01:10 +00:00
|
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
2000-10-05 01:04:57 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2008-06-22 14:28:52 +00:00
|
|
|
|
#include "config.h"
|
2000-10-05 01:04:57 +00:00
|
|
|
|
#include "gtkcellrenderer.h"
|
Adapt to GtkTreeSelection changes
2001-01-01 Havoc Pennington <hp@redhat.com>
* gtk/gtktreeview.c: Adapt to GtkTreeSelection changes
* gtk/gtktreeselection.c (_gtk_tree_selection_set_tree_view):
don't fill in tree_view->priv->selection, kind of an unexpected
side effect
* gtk/gtkcellrenderertext.c: Remove definition of _ and include
gtkintl.h
* gtk/gtkcellrenderer.c: Remove definition of _ and include
gtkintl.h
(gtk_cell_renderer_get_property): remove calls to g_value_init
* gtk/gtkcellrendererpixbuf.c: Remove definition of _ and include
gtkintl.h
* gtk/gtkcellrenderertextpixbuf.c: Remove definition of _ macro
and include gtkintl.h
(gtk_cell_renderer_text_pixbuf_class_init): remove spaces from
property names
* gtk/gtktreeselection.c (_gtk_tree_selection_new): rename, return
GtkTreeSelection
(_gtk_tree_selection_new_from_with_view): rename, return
GtkTreeSelection
(_gtk_tree_selection_set_tree_view): rename with uscore
(gtk_tree_selection_get_selected): fill in the "model" out param
first, so it gets filled in even if we return at the top of the
function
(gtk_tree_selection_real_select_all): add a comment and an else{}
to clarify this a bit
(gtk_tree_selection_real_unselect_all): add the same else{}
* gtk/gtktreeselection.h: Rename new, new_with_tree_view, and
set_tree_view to have underscore prefixes, move them to the
private header, fix return type of new_with_tree_view
(struct _GtkTreeSelection): mark struct
fields private
* gtk/gtktreemodel.c (gtk_tree_model_get_flags): return
GtkTreeModelFlags, not a guint
(gtk_tree_path_prev): return gboolean not gint
(gtk_tree_path_up): return gboolean not gint
* gtk/gtktreemodel.h (struct _GtkTreeModelIface): make get_flags
return GtkTreeModelFlags, not a guint
* gtk/gtktreemodelsort.c (gtk_tree_model_sort_finalize): check
that child model is non-null before unrefing it
(g_value_int_compare_func): make this a qsort compare func, not
a boolean predicate
* gtk/gtktreemodelsort.h: rename gtk_tree_model_set_sort_column,
(add -umn to the end), and mark it unimplemented
(gtk_tree_model_sort_resort): remove, this wasn't implemented, and
I don't see what it's for - doesn't the model always sort itself?
(gtk_tree_model_sort_set_compare): this had the wrong signature
* gtk/gtktreeviewcolumn.c (gtk_tree_view_column_set_attributes):
Fix the docs to say that it destructively replaces existing
attributes (previously said that it added attributes).
(gtk_tree_view_column_set_visible): canonicalize bool before
equality testing. Also, check for realization before
hiding/showing the tree_column->window; if this window could exist
before realization, then it's busted and needs fixing, we can't
create GDK resources pre-realization. Also, remove
superfluous queue_resize(), since set_size() does that for us.
(gtk_tree_view_column_set_col_type): check realization before
using tree_column->window
* gtk/gtktreedatalist.c: fix filename in copyright notice
2001-01-01 19:01:54 +00:00
|
|
|
|
#include "gtkintl.h"
|
2004-01-16 19:18:28 +00:00
|
|
|
|
#include "gtkmarshalers.h"
|
2011-01-04 17:05:05 +00:00
|
|
|
|
#include "gtktypebuiltins.h"
|
2005-03-22 02:14:55 +00:00
|
|
|
|
#include "gtkprivate.h"
|
add a gtk_list_store_sort_iter_changed line for some special case ...
Tue Nov 26 22:26:04 2002 Kristian Rietveld <kris@gtk.org>
* gtk/gtk{tree,list}store.c (gtk_{tree,list}_store_real_set_value):
add a gtk_list_store_sort_iter_changed line for some special
case ... (#96647 (issue 1), testcases from Soeren Sandmann and
Daniel Elstner).
Tue Nov 26 22:18:06 2002 Kristian Rietveld <kris@gtk.org>
Inconsistent state for toggle renderers, requested by Paolo Bacchilega
in #88130.
* gtk/gtktreeprivate.h: move GtkCellRendererInfo here.
* gtk/gtkcellrenderer.c: moved GtkCellRendererInfo away,
fix some indentation issues.
* gtk/gtkcellrenderertoggle.c (gtk_cell_renderer_toggle_class_init),
(gtk_cell_renderer_toggle_set_property),
(gtk_cell_renderer_toggle_get_property),
(gtk_cell_renderer_toggle_render): add an inconsistent property.
* gtk/gtkstyle.c (gtk_default_draw_check),
(gtk_default_draw_option): support drawing inconsistent
options/checks for cells.
Tue Nov 26 22:14:14 2002 Kristian Rietveld <kris@gtk.org>
* gtk/gtkcellrenderertext.c (gtk_cell_renderer_text_editing_done),
(gtk_cell_renderer_text_start_editing): add a focus_out_id to avoid
calling _editing_done twice (which has nasty side-effects). (#96647,
(issue 2) testcase from Soeren Sandmann).
Tue Nov 26 22:12:21 2002 Kristian Rietveld <kris@gtk.org>
#82739, patch from Padraig O'Briain.
* gtk/gtktreeviewcolumn.[ch]: add
gtk_tree_view_column_cell_get_position()
Tue Nov 26 22:06:29 2002 Kristian Rietveld <kris@gtk.org>
Yes, this chunk breaks ABI compatibility. Owen knows about it and
agreed with it. It doesn't break ABI that bad though, things will
still work. Please keep it silent :P.
This patch fixes some keynav issues reported by Narayana Pattipati
in #81633. (Also mentioned in #92037 (Sun tracking bug)).
* gtk/gtkmarshalers.list: add two silly marshalers
* gtk/gtktreeview.[ch] (gtk_tree_view_real_select_all),
(gtk_tree_view_real_unselect_all),
(gtk_tree_view_real_select_cursor_row),
(gtk_tree_view_real_toggle_cursor_row),
(gtk_tree_view_real_expand_collapse_cursor_row),
(gtk_tree_view_real_start_interactive_search): change the return
type from void to gboolean, update prototypes, functions, signals and
entries in GtkTreeViewClass,
(gtk_tree_view_class_init): add select_cursor_row binding for
enter key,
(gtk_tree_view_key_press): only navigate the header button if the
header is also visible ...
Tue Nov 26 22:05:48 2002 Kristian Rietveld <kris@gtk.org>
API bit of #75745, reported by Richard Hult.
* gtk/gtkcellrenderer.h (GtkCellRendererState): add
GTK_CELL_RENDERER_FOCUSED, rest of this bug fix will follow later.
2002-11-26 21:28:01 +00:00
|
|
|
|
#include "gtktreeprivate.h"
|
2011-12-15 17:17:06 +00:00
|
|
|
|
#include "a11y/gtkrenderercellaccessible.h"
|
2010-07-09 17:22:23 +00:00
|
|
|
|
|
2010-11-06 16:57:23 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* SECTION:gtkcellrenderer
|
2010-11-24 12:30:28 +00:00
|
|
|
|
* @Short_description: An object for rendering a single cell
|
2010-11-06 16:57:23 +00:00
|
|
|
|
* @Title: GtkCellRenderer
|
2018-04-02 11:59:16 +00:00
|
|
|
|
* @See_also: #GtkCellEditable
|
2010-11-06 16:57:23 +00:00
|
|
|
|
*
|
|
|
|
|
* The #GtkCellRenderer is a base class of a set of objects used for
|
2010-11-24 12:30:28 +00:00
|
|
|
|
* rendering a cell to a #cairo_t. These objects are used primarily by
|
2014-02-07 18:32:47 +00:00
|
|
|
|
* the #GtkTreeView widget, though they aren’t tied to them in any
|
2010-11-06 16:57:23 +00:00
|
|
|
|
* 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
|
2010-11-24 12:30:28 +00:00
|
|
|
|
* elements on a #cairo_t. Typically, one cell renderer is used to
|
2014-02-07 18:32:47 +00:00
|
|
|
|
* draw many cells on the screen. To this extent, it isn’t expected that a
|
2010-11-06 16:57:23 +00:00
|
|
|
|
* CellRenderer keep any permanent state around. Instead, any state is set
|
2012-05-26 19:06:00 +00:00
|
|
|
|
* just prior to use using #GObjects property system. Then, the
|
2010-11-06 16:57:23 +00:00
|
|
|
|
* cell is measured using gtk_cell_renderer_get_size(). Finally, the cell
|
|
|
|
|
* is rendered in the correct location using gtk_cell_renderer_render().
|
|
|
|
|
*
|
|
|
|
|
* There are a number of rules that must be followed when writing a new
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* #GtkCellRenderer. First and foremost, it’s important that a certain set
|
2010-11-06 16:57:23 +00:00
|
|
|
|
* 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
|
2014-02-04 23:10:11 +00:00
|
|
|
|
* “activatable” like #GtkCellRendererToggle,
|
2010-11-06 16:57:23 +00:00
|
|
|
|
* which toggles when it gets activated by a mouse click, or it can be
|
2014-02-04 23:10:11 +00:00
|
|
|
|
* “editable” like #GtkCellRendererText, which
|
2018-04-02 12:01:02 +00:00
|
|
|
|
* allows the user to edit the text using a widget implementing the
|
|
|
|
|
* #GtkCellEditable interface, e.g. #GtkEntry.
|
2010-11-06 16:57:23 +00:00
|
|
|
|
* To make a cell renderer activatable or editable, you have to
|
|
|
|
|
* implement the #GtkCellRendererClass.activate or
|
|
|
|
|
* #GtkCellRendererClass.start_editing virtual functions, respectively.
|
2012-05-26 19:06:00 +00:00
|
|
|
|
*
|
|
|
|
|
* Many properties of #GtkCellRenderer and its subclasses have a
|
2014-02-05 18:07:34 +00:00
|
|
|
|
* corresponding “set” property, e.g. “cell-background-set” corresponds
|
|
|
|
|
* to “cell-background”. These “set” properties reflect whether a property
|
2012-05-26 19:06:00 +00:00
|
|
|
|
* has been set or not. You should not set them independently.
|
2010-11-06 16:57:23 +00:00
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
2010-09-21 14:52:59 +00:00
|
|
|
|
#define DEBUG_CELL_SIZE_REQUEST 0
|
2000-10-05 01:04:57 +00:00
|
|
|
|
|
2010-08-18 23:36:51 +00:00
|
|
|
|
static void gtk_cell_renderer_init (GtkCellRenderer *cell);
|
|
|
|
|
static void gtk_cell_renderer_class_init (GtkCellRendererClass *class);
|
2000-12-12 07:32:32 +00:00
|
|
|
|
static void gtk_cell_renderer_get_property (GObject *object,
|
|
|
|
|
guint param_id,
|
|
|
|
|
GValue *value,
|
2001-03-07 14:49:21 +00:00
|
|
|
|
GParamSpec *pspec);
|
2000-12-12 07:32:32 +00:00
|
|
|
|
static void gtk_cell_renderer_set_property (GObject *object,
|
|
|
|
|
guint param_id,
|
|
|
|
|
const GValue *value,
|
2001-03-07 14:49:21 +00:00
|
|
|
|
GParamSpec *pspec);
|
2002-04-23 16:39:01 +00:00
|
|
|
|
static void set_cell_bg_color (GtkCellRenderer *cell,
|
2010-10-22 16:07:08 +00:00
|
|
|
|
GdkRGBA *rgba);
|
2000-10-05 01:04:57 +00:00
|
|
|
|
|
2010-09-21 14:52:59 +00:00
|
|
|
|
/* Fallback GtkCellRenderer implementation to use remaining ->get_size() implementations */
|
2011-02-03 10:01:55 +00:00
|
|
|
|
static GtkSizeRequestMode gtk_cell_renderer_real_get_request_mode(GtkCellRenderer *cell);
|
2010-09-21 14:52:59 +00:00
|
|
|
|
static void gtk_cell_renderer_real_get_preferred_width (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
gint *minimum_size,
|
|
|
|
|
gint *natural_size);
|
|
|
|
|
static void gtk_cell_renderer_real_get_preferred_height (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
gint *minimum_size,
|
|
|
|
|
gint *natural_size);
|
|
|
|
|
static void gtk_cell_renderer_real_get_preferred_height_for_width(GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
gint width,
|
|
|
|
|
gint *minimum_height,
|
|
|
|
|
gint *natural_height);
|
|
|
|
|
static void gtk_cell_renderer_real_get_preferred_width_for_height(GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
gint height,
|
|
|
|
|
gint *minimum_width,
|
|
|
|
|
gint *natural_width);
|
2010-11-25 08:41:26 +00:00
|
|
|
|
static void gtk_cell_renderer_real_get_aligned_area (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
GtkCellRendererState flags,
|
|
|
|
|
const GdkRectangle *cell_area,
|
|
|
|
|
GdkRectangle *aligned_area);
|
2010-08-18 23:36:51 +00:00
|
|
|
|
|
2000-10-05 01:04:57 +00:00
|
|
|
|
|
2010-08-26 17:15:37 +00:00
|
|
|
|
struct _GtkCellRendererPrivate
|
Migrating all cell renderers to use the new instance private data
Thu Dec 18 00:57:18 2003 Kristian Rietveld <kris@gtk.org>
Migrating all cell renderers to use the new instance private data
construction.
* gtk/gtktreeprivate.h: remove GtkCellRendererInfo, as it is no
longer being used.
* gtk/gtkcellrenderer.c (gtk_cell_renderer_init),
(gtk_cell_renderer_class_init), (gtk_cell_renderer_get_property),
(set_cell_bg_color), (gtk_cell_renderer_render): remove old
GtkCellRendererInfo handling, migrate to instance private data.
* gtk/gtkcellrenderertext.c (gtk_cell_renderer_text_editing_done),
(gtk_cell_renderer_text_start_editing): moved focus_out_id
from GtkCellRendererInfo to text renderer private data.
* gtk/gtkcellrendererpixbuf.c (gtk_cell_renderer_pixbuf_init),
(gtk_cell_renderer_pixbuf_class_init),
(gtk_cell_renderer_pixbuf_finalize),
(gtk_cell_renderer_pixbuf_get_property),
(gtk_cell_renderer_pixbuf_set_property),
(gtk_cell_renderer_pixbuf_create_stock_pixbuf),
(gtk_cell_renderer_pixbuf_get_size), (gtk_cell_renderer_pixbuf_render):
migrate to instance private data.
* gtk/gtkcellrenderertoggle.c (gtk_cell_renderer_toggle_class_init),
(gtk_cell_renderer_toggle_get_property),
(gtk_cell_renderer_toggle_set_property),
(gtk_cell_renderer_toggle_render): migrate to instance private data.
2003-12-18 00:06:43 +00:00
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
gfloat xalign;
|
|
|
|
|
gfloat yalign;
|
|
|
|
|
|
|
|
|
|
gint width;
|
|
|
|
|
gint height;
|
|
|
|
|
|
|
|
|
|
guint16 xpad;
|
|
|
|
|
guint16 ypad;
|
|
|
|
|
|
|
|
|
|
guint mode : 2;
|
|
|
|
|
guint visible : 1;
|
|
|
|
|
guint is_expander : 1;
|
|
|
|
|
guint is_expanded : 1;
|
|
|
|
|
guint cell_background_set : 1;
|
|
|
|
|
guint sensitive : 1;
|
|
|
|
|
guint editing : 1;
|
|
|
|
|
|
2010-10-22 16:07:08 +00:00
|
|
|
|
GdkRGBA cell_background;
|
Migrating all cell renderers to use the new instance private data
Thu Dec 18 00:57:18 2003 Kristian Rietveld <kris@gtk.org>
Migrating all cell renderers to use the new instance private data
construction.
* gtk/gtktreeprivate.h: remove GtkCellRendererInfo, as it is no
longer being used.
* gtk/gtkcellrenderer.c (gtk_cell_renderer_init),
(gtk_cell_renderer_class_init), (gtk_cell_renderer_get_property),
(set_cell_bg_color), (gtk_cell_renderer_render): remove old
GtkCellRendererInfo handling, migrate to instance private data.
* gtk/gtkcellrenderertext.c (gtk_cell_renderer_text_editing_done),
(gtk_cell_renderer_text_start_editing): moved focus_out_id
from GtkCellRendererInfo to text renderer private data.
* gtk/gtkcellrendererpixbuf.c (gtk_cell_renderer_pixbuf_init),
(gtk_cell_renderer_pixbuf_class_init),
(gtk_cell_renderer_pixbuf_finalize),
(gtk_cell_renderer_pixbuf_get_property),
(gtk_cell_renderer_pixbuf_set_property),
(gtk_cell_renderer_pixbuf_create_stock_pixbuf),
(gtk_cell_renderer_pixbuf_get_size), (gtk_cell_renderer_pixbuf_render):
migrate to instance private data.
* gtk/gtkcellrenderertoggle.c (gtk_cell_renderer_toggle_class_init),
(gtk_cell_renderer_toggle_get_property),
(gtk_cell_renderer_toggle_set_property),
(gtk_cell_renderer_toggle_render): migrate to instance private data.
2003-12-18 00:06:43 +00:00
|
|
|
|
};
|
|
|
|
|
|
2011-12-15 16:21:11 +00:00
|
|
|
|
struct _GtkCellRendererClassPrivate
|
|
|
|
|
{
|
2011-12-15 17:17:06 +00:00
|
|
|
|
GType accessible_type;
|
2011-12-15 16:21:11 +00:00
|
|
|
|
};
|
Migrating all cell renderers to use the new instance private data
Thu Dec 18 00:57:18 2003 Kristian Rietveld <kris@gtk.org>
Migrating all cell renderers to use the new instance private data
construction.
* gtk/gtktreeprivate.h: remove GtkCellRendererInfo, as it is no
longer being used.
* gtk/gtkcellrenderer.c (gtk_cell_renderer_init),
(gtk_cell_renderer_class_init), (gtk_cell_renderer_get_property),
(set_cell_bg_color), (gtk_cell_renderer_render): remove old
GtkCellRendererInfo handling, migrate to instance private data.
* gtk/gtkcellrenderertext.c (gtk_cell_renderer_text_editing_done),
(gtk_cell_renderer_text_start_editing): moved focus_out_id
from GtkCellRendererInfo to text renderer private data.
* gtk/gtkcellrendererpixbuf.c (gtk_cell_renderer_pixbuf_init),
(gtk_cell_renderer_pixbuf_class_init),
(gtk_cell_renderer_pixbuf_finalize),
(gtk_cell_renderer_pixbuf_get_property),
(gtk_cell_renderer_pixbuf_set_property),
(gtk_cell_renderer_pixbuf_create_stock_pixbuf),
(gtk_cell_renderer_pixbuf_get_size), (gtk_cell_renderer_pixbuf_render):
migrate to instance private data.
* gtk/gtkcellrenderertoggle.c (gtk_cell_renderer_toggle_class_init),
(gtk_cell_renderer_toggle_get_property),
(gtk_cell_renderer_toggle_set_property),
(gtk_cell_renderer_toggle_render): migrate to instance private data.
2003-12-18 00:06:43 +00:00
|
|
|
|
|
2000-10-05 01:04:57 +00:00
|
|
|
|
enum {
|
2008-05-19 14:15:34 +00:00
|
|
|
|
PROP_0,
|
2001-09-18 17:52:42 +00:00
|
|
|
|
PROP_MODE,
|
2001-03-07 00:57:49 +00:00
|
|
|
|
PROP_VISIBLE,
|
2004-05-27 03:31:17 +00:00
|
|
|
|
PROP_SENSITIVE,
|
2000-10-05 01:04:57 +00:00
|
|
|
|
PROP_XALIGN,
|
|
|
|
|
PROP_YALIGN,
|
|
|
|
|
PROP_XPAD,
|
2001-03-07 00:57:49 +00:00
|
|
|
|
PROP_YPAD,
|
2001-06-30 02:38:17 +00:00
|
|
|
|
PROP_WIDTH,
|
|
|
|
|
PROP_HEIGHT,
|
2001-08-19 04:19:56 +00:00
|
|
|
|
PROP_IS_EXPANDER,
|
2002-04-23 16:39:01 +00:00
|
|
|
|
PROP_IS_EXPANDED,
|
|
|
|
|
PROP_CELL_BACKGROUND,
|
|
|
|
|
PROP_CELL_BACKGROUND_GDK,
|
2010-10-22 16:07:08 +00:00
|
|
|
|
PROP_CELL_BACKGROUND_RGBA,
|
2008-06-20 11:01:02 +00:00
|
|
|
|
PROP_CELL_BACKGROUND_SET,
|
|
|
|
|
PROP_EDITING
|
2000-10-05 01:04:57 +00:00
|
|
|
|
};
|
|
|
|
|
|
2004-01-16 19:18:28 +00:00
|
|
|
|
/* Signal IDs */
|
|
|
|
|
enum {
|
|
|
|
|
EDITING_CANCELED,
|
2004-07-20 16:06:02 +00:00
|
|
|
|
EDITING_STARTED,
|
2004-01-16 19:18:28 +00:00
|
|
|
|
LAST_SIGNAL
|
|
|
|
|
};
|
|
|
|
|
|
2013-06-27 19:02:52 +00:00
|
|
|
|
static gint GtkCellRenderer_private_offset;
|
2010-08-18 23:36:51 +00:00
|
|
|
|
static guint cell_renderer_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
|
|
2013-06-27 19:02:52 +00:00
|
|
|
|
static inline gpointer
|
|
|
|
|
gtk_cell_renderer_get_instance_private (GtkCellRenderer *self)
|
|
|
|
|
{
|
|
|
|
|
return (G_STRUCT_MEMBER_P (self, GtkCellRenderer_private_offset));
|
|
|
|
|
}
|
|
|
|
|
|
2000-10-05 01:04:57 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_cell_renderer_init (GtkCellRenderer *cell)
|
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2010-05-30 20:21:33 +00:00
|
|
|
|
|
2013-06-27 19:02:52 +00:00
|
|
|
|
cell->priv = gtk_cell_renderer_get_instance_private (cell);
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
|
|
|
|
priv->mode = GTK_CELL_RENDERER_MODE_INERT;
|
|
|
|
|
priv->visible = TRUE;
|
|
|
|
|
priv->width = -1;
|
|
|
|
|
priv->height = -1;
|
|
|
|
|
priv->xalign = 0.5;
|
|
|
|
|
priv->yalign = 0.5;
|
|
|
|
|
priv->xpad = 0;
|
|
|
|
|
priv->ypad = 0;
|
|
|
|
|
priv->sensitive = TRUE;
|
|
|
|
|
priv->is_expander = FALSE;
|
|
|
|
|
priv->is_expanded = FALSE;
|
|
|
|
|
priv->editing = FALSE;
|
2000-10-05 01:04:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_cell_renderer_class_init (GtkCellRendererClass *class)
|
|
|
|
|
{
|
|
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (class);
|
|
|
|
|
|
2000-12-12 07:32:32 +00:00
|
|
|
|
object_class->get_property = gtk_cell_renderer_get_property;
|
|
|
|
|
object_class->set_property = gtk_cell_renderer_set_property;
|
2000-10-05 01:04:57 +00:00
|
|
|
|
|
|
|
|
|
class->render = NULL;
|
|
|
|
|
class->get_size = NULL;
|
2011-02-03 10:01:55 +00:00
|
|
|
|
class->get_request_mode = gtk_cell_renderer_real_get_request_mode;
|
2010-09-21 14:52:59 +00:00
|
|
|
|
class->get_preferred_width = gtk_cell_renderer_real_get_preferred_width;
|
|
|
|
|
class->get_preferred_height = gtk_cell_renderer_real_get_preferred_height;
|
|
|
|
|
class->get_preferred_width_for_height = gtk_cell_renderer_real_get_preferred_width_for_height;
|
|
|
|
|
class->get_preferred_height_for_width = gtk_cell_renderer_real_get_preferred_height_for_width;
|
2010-11-25 08:41:26 +00:00
|
|
|
|
class->get_aligned_area = gtk_cell_renderer_real_get_aligned_area;
|
2000-10-05 01:04:57 +00:00
|
|
|
|
|
2004-01-16 19:18:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkCellRenderer::editing-canceled:
|
2004-04-15 14:31:02 +00:00
|
|
|
|
* @renderer: the object which received the signal
|
2004-01-16 19:18:28 +00:00
|
|
|
|
*
|
|
|
|
|
* 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
|
2004-07-20 16:06:02 +00:00
|
|
|
|
* editing when the user presses Escape.
|
2004-01-16 19:18:28 +00:00
|
|
|
|
*
|
2007-07-12 01:55:15 +00:00
|
|
|
|
* See also: gtk_cell_renderer_stop_editing().
|
2004-01-16 19:18:28 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 2.4
|
|
|
|
|
*/
|
|
|
|
|
cell_renderer_signals[EDITING_CANCELED] =
|
2005-09-01 05:11:46 +00:00
|
|
|
|
g_signal_new (I_("editing-canceled"),
|
2004-01-16 19:18:28 +00:00
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_FIRST,
|
|
|
|
|
G_STRUCT_OFFSET (GtkCellRendererClass, editing_canceled),
|
|
|
|
|
NULL, NULL,
|
2016-08-29 14:00:17 +00:00
|
|
|
|
NULL,
|
2004-01-16 19:18:28 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
|
2004-07-20 16:06:02 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkCellRenderer::editing-started:
|
|
|
|
|
* @renderer: the object which received the signal
|
|
|
|
|
* @editable: the #GtkCellEditable
|
|
|
|
|
* @path: the path identifying the edited cell
|
|
|
|
|
*
|
|
|
|
|
* This signal gets emitted when a cell starts to be edited.
|
2009-11-07 23:10:45 +00:00
|
|
|
|
* The intended use of this signal is to do special setup
|
2004-07-20 16:06:02 +00:00
|
|
|
|
* on @editable, e.g. adding a #GtkEntryCompletion or setting
|
|
|
|
|
* up additional columns in a #GtkComboBox.
|
|
|
|
|
*
|
2018-04-03 19:01:54 +00:00
|
|
|
|
* See gtk_cell_editable_start_editing() for information on the lifecycle of
|
|
|
|
|
* the @editable and a way to do setup that doesn’t depend on the @renderer.
|
|
|
|
|
*
|
2004-07-20 16:06:02 +00:00
|
|
|
|
* 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:
|
2014-01-27 19:55:18 +00:00
|
|
|
|
* |[<!-- language="C" -->
|
2004-07-20 16:06:02 +00:00
|
|
|
|
* static void
|
|
|
|
|
* text_editing_started (GtkCellRenderer *cell,
|
|
|
|
|
* GtkCellEditable *editable,
|
|
|
|
|
* const gchar *path,
|
|
|
|
|
* gpointer data)
|
|
|
|
|
* {
|
|
|
|
|
* if (GTK_IS_ENTRY (editable))
|
|
|
|
|
* {
|
|
|
|
|
* GtkEntry *entry = GTK_ENTRY (editable);
|
2007-11-25 06:51:19 +00:00
|
|
|
|
*
|
2014-02-15 04:34:22 +00:00
|
|
|
|
* // ... create a GtkEntryCompletion
|
2007-11-25 06:51:19 +00:00
|
|
|
|
*
|
2004-07-20 16:06:02 +00:00
|
|
|
|
* gtk_entry_set_completion (entry, completion);
|
|
|
|
|
* }
|
|
|
|
|
* }
|
2007-11-25 06:51:19 +00:00
|
|
|
|
* ]|
|
2004-07-20 16:06:02 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 2.6
|
|
|
|
|
*/
|
|
|
|
|
cell_renderer_signals[EDITING_STARTED] =
|
2005-09-01 05:11:46 +00:00
|
|
|
|
g_signal_new (I_("editing-started"),
|
2004-07-20 16:06:02 +00:00
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_FIRST,
|
|
|
|
|
G_STRUCT_OFFSET (GtkCellRendererClass, editing_started),
|
|
|
|
|
NULL, NULL,
|
|
|
|
|
_gtk_marshal_VOID__OBJECT_STRING,
|
|
|
|
|
G_TYPE_NONE, 2,
|
|
|
|
|
GTK_TYPE_CELL_EDITABLE,
|
|
|
|
|
G_TYPE_STRING);
|
|
|
|
|
|
2001-03-15 23:21:39 +00:00
|
|
|
|
g_object_class_install_property (object_class,
|
2001-09-18 17:52:42 +00:00
|
|
|
|
PROP_MODE,
|
|
|
|
|
g_param_spec_enum ("mode",
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("mode"),
|
|
|
|
|
P_("Editable mode of the CellRenderer"),
|
2001-09-18 17:52:42 +00:00
|
|
|
|
GTK_TYPE_CELL_RENDERER_MODE,
|
|
|
|
|
GTK_CELL_RENDERER_MODE_INERT,
|
2014-06-08 15:25:40 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
|
2001-03-15 23:21:39 +00:00
|
|
|
|
|
2001-03-07 00:57:49 +00:00
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_VISIBLE,
|
|
|
|
|
g_param_spec_boolean ("visible",
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("visible"),
|
|
|
|
|
P_("Display the cell"),
|
2001-03-07 00:57:49 +00:00
|
|
|
|
TRUE,
|
2014-06-08 15:25:40 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
|
2004-05-27 03:31:17 +00:00
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_SENSITIVE,
|
|
|
|
|
g_param_spec_boolean ("sensitive",
|
|
|
|
|
P_("Sensitive"),
|
|
|
|
|
P_("Display the cell sensitive"),
|
|
|
|
|
TRUE,
|
2014-06-08 15:25:40 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
|
2001-03-15 23:21:39 +00:00
|
|
|
|
|
2000-12-12 07:32:32 +00:00
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_XALIGN,
|
|
|
|
|
g_param_spec_float ("xalign",
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("xalign"),
|
|
|
|
|
P_("The x-align"),
|
2000-12-12 07:32:32 +00:00
|
|
|
|
0.0,
|
|
|
|
|
1.0,
|
2004-07-15 17:48:04 +00:00
|
|
|
|
0.5,
|
2014-06-08 15:25:40 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
|
2001-03-15 23:21:39 +00:00
|
|
|
|
|
2000-12-12 07:32:32 +00:00
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_YALIGN,
|
|
|
|
|
g_param_spec_float ("yalign",
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("yalign"),
|
|
|
|
|
P_("The y-align"),
|
2000-12-12 07:32:32 +00:00
|
|
|
|
0.0,
|
|
|
|
|
1.0,
|
|
|
|
|
0.5,
|
2014-06-08 15:25:40 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
|
2001-03-15 23:21:39 +00:00
|
|
|
|
|
2000-12-12 07:32:32 +00:00
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_XPAD,
|
|
|
|
|
g_param_spec_uint ("xpad",
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("xpad"),
|
|
|
|
|
P_("The xpad"),
|
2000-12-12 07:32:32 +00:00
|
|
|
|
0,
|
2004-02-11 01:09:25 +00:00
|
|
|
|
G_MAXUINT,
|
2004-07-15 17:48:04 +00:00
|
|
|
|
0,
|
2014-06-08 15:25:40 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
|
2001-03-15 23:21:39 +00:00
|
|
|
|
|
2000-12-12 07:32:32 +00:00
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_YPAD,
|
|
|
|
|
g_param_spec_uint ("ypad",
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("ypad"),
|
|
|
|
|
P_("The ypad"),
|
2000-12-12 07:32:32 +00:00
|
|
|
|
0,
|
2004-02-11 01:09:25 +00:00
|
|
|
|
G_MAXUINT,
|
2004-07-15 17:48:04 +00:00
|
|
|
|
0,
|
2014-06-08 15:25:40 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
|
2001-06-30 02:38:17 +00:00
|
|
|
|
|
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_WIDTH,
|
|
|
|
|
g_param_spec_int ("width",
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("width"),
|
|
|
|
|
P_("The fixed width"),
|
2001-06-30 02:38:17 +00:00
|
|
|
|
-1,
|
2004-02-11 01:09:25 +00:00
|
|
|
|
G_MAXINT,
|
2001-06-30 02:38:17 +00:00
|
|
|
|
-1,
|
2014-06-08 15:25:40 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
|
2001-06-30 02:38:17 +00:00
|
|
|
|
|
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_HEIGHT,
|
|
|
|
|
g_param_spec_int ("height",
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("height"),
|
|
|
|
|
P_("The fixed height"),
|
2001-06-30 02:38:17 +00:00
|
|
|
|
-1,
|
2004-02-11 01:09:25 +00:00
|
|
|
|
G_MAXINT,
|
2001-06-30 02:38:17 +00:00
|
|
|
|
-1,
|
2014-06-08 15:25:40 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
|
2001-08-19 04:19:56 +00:00
|
|
|
|
|
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_IS_EXPANDER,
|
2005-03-09 04:04:40 +00:00
|
|
|
|
g_param_spec_boolean ("is-expander",
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("Is Expander"),
|
|
|
|
|
P_("Row has children"),
|
2001-08-19 04:19:56 +00:00
|
|
|
|
FALSE,
|
2014-06-08 15:25:40 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
|
2001-08-19 04:19:56 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_IS_EXPANDED,
|
2005-03-09 04:04:40 +00:00
|
|
|
|
g_param_spec_boolean ("is-expanded",
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("Is Expanded"),
|
|
|
|
|
P_("Row is an expander row, and is expanded"),
|
2001-08-19 04:19:56 +00:00
|
|
|
|
FALSE,
|
2014-06-08 15:25:40 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
|
2002-04-23 16:39:01 +00:00
|
|
|
|
|
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_CELL_BACKGROUND,
|
2005-03-09 04:04:40 +00:00
|
|
|
|
g_param_spec_string ("cell-background",
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("Cell background color name"),
|
|
|
|
|
P_("Cell background color as a string"),
|
2002-04-23 16:39:01 +00:00
|
|
|
|
NULL,
|
2005-03-22 02:14:55 +00:00
|
|
|
|
GTK_PARAM_WRITABLE));
|
2002-04-23 16:39:01 +00:00
|
|
|
|
|
2011-12-13 11:02:13 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkCellRenderer:cell-background-gdk:
|
|
|
|
|
*
|
|
|
|
|
* Cell background as a #GdkColor
|
|
|
|
|
*
|
|
|
|
|
* Deprecated: 3.4: Use #GtkCellRenderer:cell-background-rgba instead.
|
|
|
|
|
*/
|
2014-05-22 13:05:58 +00:00
|
|
|
|
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
|
2002-04-23 16:39:01 +00:00
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_CELL_BACKGROUND_GDK,
|
2005-03-09 04:04:40 +00:00
|
|
|
|
g_param_spec_boxed ("cell-background-gdk",
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("Cell background color"),
|
|
|
|
|
P_("Cell background color as a GdkColor"),
|
2002-04-23 16:39:01 +00:00
|
|
|
|
GDK_TYPE_COLOR,
|
2014-06-08 15:25:40 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_DEPRECATED));
|
2014-05-22 13:05:58 +00:00
|
|
|
|
G_GNUC_END_IGNORE_DEPRECATIONS
|
2010-10-22 16:07:08 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkCellRenderer:cell-background-rgba:
|
|
|
|
|
*
|
|
|
|
|
* Cell background as a #GdkRGBA
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.0
|
|
|
|
|
*/
|
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_CELL_BACKGROUND_RGBA,
|
|
|
|
|
g_param_spec_boxed ("cell-background-rgba",
|
|
|
|
|
P_("Cell background RGBA color"),
|
|
|
|
|
P_("Cell background color as a GdkRGBA"),
|
|
|
|
|
GDK_TYPE_RGBA,
|
|
|
|
|
GTK_PARAM_READWRITE));
|
2002-04-23 16:39:01 +00:00
|
|
|
|
|
2008-06-20 11:01:02 +00:00
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
PROP_EDITING,
|
|
|
|
|
g_param_spec_boolean ("editing",
|
|
|
|
|
P_("Editing"),
|
|
|
|
|
P_("Whether the cell renderer is currently in editing mode"),
|
|
|
|
|
FALSE,
|
2008-06-20 11:09:24 +00:00
|
|
|
|
GTK_PARAM_READABLE));
|
2008-06-20 11:01:02 +00:00
|
|
|
|
|
2002-04-23 16:39:01 +00:00
|
|
|
|
|
2014-06-08 15:25:40 +00:00
|
|
|
|
#define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (object_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY))
|
2002-04-23 16:39:01 +00:00
|
|
|
|
|
2005-03-09 04:04:40 +00:00
|
|
|
|
ADD_SET_PROP ("cell-background-set", PROP_CELL_BACKGROUND_SET,
|
2004-01-16 23:10:05 +00:00
|
|
|
|
P_("Cell background set"),
|
2012-05-26 19:06:00 +00:00
|
|
|
|
P_("Whether the cell background color is set"));
|
Migrating all cell renderers to use the new instance private data
Thu Dec 18 00:57:18 2003 Kristian Rietveld <kris@gtk.org>
Migrating all cell renderers to use the new instance private data
construction.
* gtk/gtktreeprivate.h: remove GtkCellRendererInfo, as it is no
longer being used.
* gtk/gtkcellrenderer.c (gtk_cell_renderer_init),
(gtk_cell_renderer_class_init), (gtk_cell_renderer_get_property),
(set_cell_bg_color), (gtk_cell_renderer_render): remove old
GtkCellRendererInfo handling, migrate to instance private data.
* gtk/gtkcellrenderertext.c (gtk_cell_renderer_text_editing_done),
(gtk_cell_renderer_text_start_editing): moved focus_out_id
from GtkCellRendererInfo to text renderer private data.
* gtk/gtkcellrendererpixbuf.c (gtk_cell_renderer_pixbuf_init),
(gtk_cell_renderer_pixbuf_class_init),
(gtk_cell_renderer_pixbuf_finalize),
(gtk_cell_renderer_pixbuf_get_property),
(gtk_cell_renderer_pixbuf_set_property),
(gtk_cell_renderer_pixbuf_create_stock_pixbuf),
(gtk_cell_renderer_pixbuf_get_size), (gtk_cell_renderer_pixbuf_render):
migrate to instance private data.
* gtk/gtkcellrenderertoggle.c (gtk_cell_renderer_toggle_class_init),
(gtk_cell_renderer_toggle_get_property),
(gtk_cell_renderer_toggle_set_property),
(gtk_cell_renderer_toggle_render): migrate to instance private data.
2003-12-18 00:06:43 +00:00
|
|
|
|
|
2013-06-27 19:02:52 +00:00
|
|
|
|
if (GtkCellRenderer_private_offset != 0)
|
|
|
|
|
g_type_class_adjust_private_offset (class, &GtkCellRenderer_private_offset);
|
2011-12-15 17:17:06 +00:00
|
|
|
|
|
2013-02-25 20:41:30 +00:00
|
|
|
|
gtk_cell_renderer_class_set_accessible_type (class, GTK_TYPE_RENDERER_CELL_ACCESSIBLE);
|
2000-10-05 01:04:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-12-15 16:21:11 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_cell_renderer_base_class_init (gpointer g_class)
|
|
|
|
|
{
|
|
|
|
|
GtkCellRendererClass *klass = g_class;
|
|
|
|
|
|
|
|
|
|
klass->priv = G_TYPE_CLASS_GET_PRIVATE (g_class, GTK_TYPE_CELL_RENDERER, GtkCellRendererClassPrivate);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
GType
|
|
|
|
|
gtk_cell_renderer_get_type (void)
|
|
|
|
|
{
|
|
|
|
|
static GType cell_renderer_type = 0;
|
|
|
|
|
|
|
|
|
|
if (G_UNLIKELY (cell_renderer_type == 0))
|
|
|
|
|
{
|
|
|
|
|
const GTypeInfo cell_renderer_info =
|
|
|
|
|
{
|
|
|
|
|
sizeof (GtkCellRendererClass),
|
|
|
|
|
gtk_cell_renderer_base_class_init,
|
|
|
|
|
NULL,
|
|
|
|
|
(GClassInitFunc) gtk_cell_renderer_class_init,
|
|
|
|
|
NULL, /* class_finalize */
|
|
|
|
|
NULL, /* class_init */
|
|
|
|
|
sizeof (GtkWidget),
|
|
|
|
|
0, /* n_preallocs */
|
|
|
|
|
(GInstanceInitFunc) gtk_cell_renderer_init,
|
|
|
|
|
NULL, /* value_table */
|
|
|
|
|
};
|
|
|
|
|
cell_renderer_type = g_type_register_static (G_TYPE_INITIALLY_UNOWNED, "GtkCellRenderer",
|
|
|
|
|
&cell_renderer_info, G_TYPE_FLAG_ABSTRACT);
|
|
|
|
|
|
2013-06-27 19:02:52 +00:00
|
|
|
|
GtkCellRenderer_private_offset =
|
|
|
|
|
g_type_add_instance_private (cell_renderer_type, sizeof (GtkCellRendererPrivate));
|
2011-12-15 16:21:11 +00:00
|
|
|
|
g_type_add_class_private (cell_renderer_type, sizeof (GtkCellRendererClassPrivate));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return cell_renderer_type;
|
|
|
|
|
}
|
|
|
|
|
|
2000-10-05 01:04:57 +00:00
|
|
|
|
static void
|
2000-12-12 07:32:32 +00:00
|
|
|
|
gtk_cell_renderer_get_property (GObject *object,
|
|
|
|
|
guint param_id,
|
|
|
|
|
GValue *value,
|
2001-03-07 14:49:21 +00:00
|
|
|
|
GParamSpec *pspec)
|
2000-10-05 01:04:57 +00:00
|
|
|
|
{
|
|
|
|
|
GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv = cell->priv;
|
2000-10-05 01:04:57 +00:00
|
|
|
|
|
|
|
|
|
switch (param_id)
|
|
|
|
|
{
|
2001-09-18 17:52:42 +00:00
|
|
|
|
case PROP_MODE:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_enum (value, priv->mode);
|
2001-09-17 21:44:20 +00:00
|
|
|
|
break;
|
2001-03-07 00:57:49 +00:00
|
|
|
|
case PROP_VISIBLE:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_boolean (value, priv->visible);
|
2001-03-07 00:57:49 +00:00
|
|
|
|
break;
|
2004-05-27 03:31:17 +00:00
|
|
|
|
case PROP_SENSITIVE:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_boolean (value, priv->sensitive);
|
2004-05-27 03:31:17 +00:00
|
|
|
|
break;
|
2008-06-20 11:01:02 +00:00
|
|
|
|
case PROP_EDITING:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_boolean (value, priv->editing);
|
2008-06-20 11:01:02 +00:00
|
|
|
|
break;
|
2000-10-05 01:04:57 +00:00
|
|
|
|
case PROP_XALIGN:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_float (value, priv->xalign);
|
2000-10-05 01:04:57 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_YALIGN:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_float (value, priv->yalign);
|
2000-10-05 01:04:57 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_XPAD:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_uint (value, priv->xpad);
|
2000-10-05 01:04:57 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_YPAD:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_uint (value, priv->ypad);
|
2000-10-05 01:04:57 +00:00
|
|
|
|
break;
|
2001-06-30 02:38:17 +00:00
|
|
|
|
case PROP_WIDTH:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_int (value, priv->width);
|
2001-06-30 02:38:17 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_HEIGHT:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_int (value, priv->height);
|
2001-06-30 02:38:17 +00:00
|
|
|
|
break;
|
2001-08-19 04:19:56 +00:00
|
|
|
|
case PROP_IS_EXPANDER:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_boolean (value, priv->is_expander);
|
2001-08-19 04:19:56 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_IS_EXPANDED:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_boolean (value, priv->is_expanded);
|
2001-08-19 04:19:56 +00:00
|
|
|
|
break;
|
2002-04-23 16:39:01 +00:00
|
|
|
|
case PROP_CELL_BACKGROUND_GDK:
|
|
|
|
|
{
|
|
|
|
|
GdkColor color;
|
|
|
|
|
|
2010-10-22 16:07:08 +00:00
|
|
|
|
color.red = (guint16) (priv->cell_background.red * 65535);
|
|
|
|
|
color.green = (guint16) (priv->cell_background.green * 65535);
|
|
|
|
|
color.blue = (guint16) (priv->cell_background.blue * 65535);
|
2002-04-23 16:39:01 +00:00
|
|
|
|
|
|
|
|
|
g_value_set_boxed (value, &color);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2010-10-22 16:07:08 +00:00
|
|
|
|
case PROP_CELL_BACKGROUND_RGBA:
|
|
|
|
|
g_value_set_boxed (value, &priv->cell_background);
|
|
|
|
|
break;
|
2002-04-23 16:39:01 +00:00
|
|
|
|
case PROP_CELL_BACKGROUND_SET:
|
2010-05-30 20:21:33 +00:00
|
|
|
|
g_value_set_boolean (value, priv->cell_background_set);
|
2002-04-23 16:39:01 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_CELL_BACKGROUND:
|
2000-10-05 01:04:57 +00:00
|
|
|
|
default:
|
2000-12-12 07:32:32 +00:00
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
|
2000-10-05 01:04:57 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2000-12-12 07:32:32 +00:00
|
|
|
|
gtk_cell_renderer_set_property (GObject *object,
|
|
|
|
|
guint param_id,
|
|
|
|
|
const GValue *value,
|
2001-03-07 14:49:21 +00:00
|
|
|
|
GParamSpec *pspec)
|
2000-10-05 01:04:57 +00:00
|
|
|
|
{
|
|
|
|
|
GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv = cell->priv;
|
2000-10-05 01:04:57 +00:00
|
|
|
|
|
|
|
|
|
switch (param_id)
|
|
|
|
|
{
|
2001-09-18 17:52:42 +00:00
|
|
|
|
case PROP_MODE:
|
2014-06-08 15:25:40 +00:00
|
|
|
|
if (priv->mode != g_value_get_enum (value))
|
|
|
|
|
{
|
|
|
|
|
priv->mode = g_value_get_enum (value);
|
|
|
|
|
g_object_notify_by_pspec (object, pspec);
|
|
|
|
|
}
|
2001-03-15 23:21:39 +00:00
|
|
|
|
break;
|
2001-03-07 00:57:49 +00:00
|
|
|
|
case PROP_VISIBLE:
|
2014-06-08 15:25:40 +00:00
|
|
|
|
if (priv->visible != g_value_get_boolean (value))
|
|
|
|
|
{
|
|
|
|
|
priv->visible = g_value_get_boolean (value);
|
|
|
|
|
g_object_notify_by_pspec (object, pspec);
|
|
|
|
|
}
|
2001-03-07 00:57:49 +00:00
|
|
|
|
break;
|
2004-05-27 03:31:17 +00:00
|
|
|
|
case PROP_SENSITIVE:
|
2014-06-08 15:25:40 +00:00
|
|
|
|
if (priv->sensitive != g_value_get_boolean (value))
|
|
|
|
|
{
|
|
|
|
|
priv->sensitive = g_value_get_boolean (value);
|
|
|
|
|
g_object_notify_by_pspec (object, pspec);
|
|
|
|
|
}
|
2008-06-20 11:01:02 +00:00
|
|
|
|
break;
|
2000-10-05 01:04:57 +00:00
|
|
|
|
case PROP_XALIGN:
|
2014-06-08 15:25:40 +00:00
|
|
|
|
if (priv->xalign != g_value_get_float (value))
|
|
|
|
|
{
|
|
|
|
|
priv->xalign = g_value_get_float (value);
|
|
|
|
|
g_object_notify_by_pspec (object, pspec);
|
|
|
|
|
}
|
2000-10-05 01:04:57 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_YALIGN:
|
2014-06-08 15:25:40 +00:00
|
|
|
|
if (priv->yalign != g_value_get_float (value))
|
|
|
|
|
{
|
|
|
|
|
priv->yalign = g_value_get_float (value);
|
|
|
|
|
g_object_notify_by_pspec (object, pspec);
|
|
|
|
|
}
|
2000-10-05 01:04:57 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_XPAD:
|
2014-06-08 15:25:40 +00:00
|
|
|
|
if (priv->xpad != g_value_get_uint (value))
|
|
|
|
|
{
|
|
|
|
|
priv->xpad = g_value_get_uint (value);
|
|
|
|
|
g_object_notify_by_pspec (object, pspec);
|
|
|
|
|
}
|
2000-10-05 01:04:57 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_YPAD:
|
2014-06-08 15:25:40 +00:00
|
|
|
|
if (priv->ypad != g_value_get_uint (value))
|
|
|
|
|
{
|
|
|
|
|
priv->ypad = g_value_get_uint (value);
|
|
|
|
|
g_object_notify_by_pspec (object, pspec);
|
|
|
|
|
}
|
2000-10-05 01:04:57 +00:00
|
|
|
|
break;
|
2001-06-30 02:38:17 +00:00
|
|
|
|
case PROP_WIDTH:
|
2014-06-08 15:25:40 +00:00
|
|
|
|
if (priv->width != g_value_get_int (value))
|
|
|
|
|
{
|
|
|
|
|
priv->width = g_value_get_int (value);
|
|
|
|
|
g_object_notify_by_pspec (object, pspec);
|
|
|
|
|
}
|
2001-06-30 02:38:17 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_HEIGHT:
|
2014-06-08 15:25:40 +00:00
|
|
|
|
if (priv->height != g_value_get_int (value))
|
|
|
|
|
{
|
|
|
|
|
priv->height = g_value_get_int (value);
|
|
|
|
|
g_object_notify_by_pspec (object, pspec);
|
|
|
|
|
}
|
2001-06-30 02:38:17 +00:00
|
|
|
|
break;
|
2001-08-19 04:19:56 +00:00
|
|
|
|
case PROP_IS_EXPANDER:
|
2014-06-08 15:25:40 +00:00
|
|
|
|
if (priv->is_expander != g_value_get_boolean (value))
|
|
|
|
|
{
|
|
|
|
|
priv->is_expander = g_value_get_boolean (value);
|
|
|
|
|
g_object_notify_by_pspec (object, pspec);
|
|
|
|
|
}
|
2001-08-19 04:19:56 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_IS_EXPANDED:
|
2014-06-08 15:25:40 +00:00
|
|
|
|
if (priv->is_expanded != g_value_get_boolean (value))
|
|
|
|
|
{
|
|
|
|
|
priv->is_expanded = g_value_get_boolean (value);
|
|
|
|
|
g_object_notify_by_pspec (object, pspec);
|
|
|
|
|
}
|
2001-08-19 04:19:56 +00:00
|
|
|
|
break;
|
2002-04-23 16:39:01 +00:00
|
|
|
|
case PROP_CELL_BACKGROUND:
|
|
|
|
|
{
|
2010-10-22 16:07:08 +00:00
|
|
|
|
GdkRGBA rgba;
|
2002-04-23 16:39:01 +00:00
|
|
|
|
|
2010-10-25 15:17:24 +00:00
|
|
|
|
if (!g_value_get_string (value))
|
|
|
|
|
set_cell_bg_color (cell, NULL);
|
2010-11-28 18:49:47 +00:00
|
|
|
|
else if (gdk_rgba_parse (&rgba, g_value_get_string (value)))
|
2010-10-25 15:17:24 +00:00
|
|
|
|
set_cell_bg_color (cell, &rgba);
|
|
|
|
|
else
|
2015-09-20 06:32:48 +00:00
|
|
|
|
g_warning ("Don't know color '%s'", g_value_get_string (value));
|
2010-10-25 15:17:24 +00:00
|
|
|
|
|
2014-06-08 15:25:40 +00:00
|
|
|
|
g_object_notify (object, "cell-background");
|
2002-04-23 16:39:01 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case PROP_CELL_BACKGROUND_GDK:
|
2010-10-22 16:07:08 +00:00
|
|
|
|
{
|
|
|
|
|
GdkColor *color;
|
|
|
|
|
|
|
|
|
|
color = g_value_get_boxed (value);
|
2010-10-25 15:17:24 +00:00
|
|
|
|
if (color)
|
|
|
|
|
{
|
|
|
|
|
GdkRGBA rgba;
|
|
|
|
|
|
|
|
|
|
rgba.red = color->red / 65535.;
|
|
|
|
|
rgba.green = color->green / 65535.;
|
|
|
|
|
rgba.blue = color->blue / 65535.;
|
|
|
|
|
rgba.alpha = 1;
|
|
|
|
|
|
|
|
|
|
set_cell_bg_color (cell, &rgba);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
set_cell_bg_color (cell, NULL);
|
|
|
|
|
}
|
2014-06-08 15:25:40 +00:00
|
|
|
|
g_object_notify (object, "cell-background-gdk");
|
2010-10-22 16:07:08 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case PROP_CELL_BACKGROUND_RGBA:
|
2002-04-23 16:39:01 +00:00
|
|
|
|
set_cell_bg_color (cell, g_value_get_boxed (value));
|
|
|
|
|
break;
|
|
|
|
|
case PROP_CELL_BACKGROUND_SET:
|
2014-06-08 15:25:40 +00:00
|
|
|
|
if (priv->cell_background_set != g_value_get_boolean (value))
|
|
|
|
|
{
|
|
|
|
|
priv->cell_background_set = g_value_get_boolean (value);
|
|
|
|
|
g_object_notify (object, "cell-background-set");
|
|
|
|
|
}
|
2002-04-23 16:39:01 +00:00
|
|
|
|
break;
|
2000-10-05 01:04:57 +00:00
|
|
|
|
default:
|
2000-12-12 07:32:32 +00:00
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
|
2000-10-05 01:04:57 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-04-23 16:39:01 +00:00
|
|
|
|
static void
|
|
|
|
|
set_cell_bg_color (GtkCellRenderer *cell,
|
2010-10-22 16:07:08 +00:00
|
|
|
|
GdkRGBA *rgba)
|
2002-04-23 16:39:01 +00:00
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv = cell->priv;
|
2002-04-26 19:45:22 +00:00
|
|
|
|
|
2010-10-22 16:07:08 +00:00
|
|
|
|
if (rgba)
|
2002-04-23 16:39:01 +00:00
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
if (!priv->cell_background_set)
|
2002-04-23 16:39:01 +00:00
|
|
|
|
{
|
2010-10-25 15:17:24 +00:00
|
|
|
|
priv->cell_background_set = TRUE;
|
|
|
|
|
g_object_notify (G_OBJECT (cell), "cell-background-set");
|
|
|
|
|
}
|
2002-04-23 16:39:01 +00:00
|
|
|
|
|
2010-10-22 16:07:08 +00:00
|
|
|
|
priv->cell_background = *rgba;
|
2002-04-23 16:39:01 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
if (priv->cell_background_set)
|
2002-04-23 16:39:01 +00:00
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv->cell_background_set = FALSE;
|
2005-03-26 05:49:15 +00:00
|
|
|
|
g_object_notify (G_OBJECT (cell), "cell-background-set");
|
2002-04-23 16:39:01 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2014-06-08 15:25:40 +00:00
|
|
|
|
g_object_notify (G_OBJECT (cell), "cell-background-rgba");
|
2002-04-23 16:39:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2001-02-03 01:09:41 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_size:
|
|
|
|
|
* @cell: a #GtkCellRenderer
|
|
|
|
|
* @widget: the widget the renderer is rendering to
|
2010-02-19 16:53:17 +00:00
|
|
|
|
* @cell_area: (allow-none): The area a cell will be allocated, or %NULL
|
2011-01-18 09:10:30 +00:00
|
|
|
|
* @x_offset: (out) (allow-none): location to return x offset of cell relative to @cell_area, or %NULL
|
|
|
|
|
* @y_offset: (out) (allow-none): location to return y offset of cell relative to @cell_area, or %NULL
|
|
|
|
|
* @width: (out) (allow-none): location to return width needed to render a cell, or %NULL
|
|
|
|
|
* @height: (out) (allow-none): location to return height needed to render a cell, or %NULL
|
2001-03-15 23:21:39 +00:00
|
|
|
|
*
|
2007-07-12 01:55:15 +00:00
|
|
|
|
* 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.
|
2010-08-18 23:36:51 +00:00
|
|
|
|
*
|
|
|
|
|
*
|
2010-09-21 14:52:59 +00:00
|
|
|
|
* Deprecated: 3.0: Use gtk_cell_renderer_get_preferred_size() instead.
|
2001-02-03 01:09:41 +00:00
|
|
|
|
**/
|
2000-10-05 01:04:57 +00:00
|
|
|
|
void
|
2008-01-25 09:30:40 +00:00
|
|
|
|
gtk_cell_renderer_get_size (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
const GdkRectangle *cell_area,
|
|
|
|
|
gint *x_offset,
|
|
|
|
|
gint *y_offset,
|
|
|
|
|
gint *width,
|
|
|
|
|
gint *height)
|
2000-10-05 01:04:57 +00:00
|
|
|
|
{
|
2010-08-18 23:36:51 +00:00
|
|
|
|
GtkRequisition request;
|
2001-06-30 02:38:17 +00:00
|
|
|
|
|
2000-10-05 01:04:57 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
|
2010-09-21 14:52:59 +00:00
|
|
|
|
gtk_cell_renderer_get_preferred_size (cell, widget, &request, NULL);
|
2010-05-30 20:21:33 +00:00
|
|
|
|
|
2010-08-18 23:36:51 +00:00
|
|
|
|
if (width)
|
|
|
|
|
*width = request.width;
|
|
|
|
|
|
|
|
|
|
if (height)
|
|
|
|
|
*height = request.height;
|
2001-06-30 02:38:17 +00:00
|
|
|
|
|
2010-08-18 23:36:51 +00:00
|
|
|
|
if (cell_area)
|
|
|
|
|
_gtk_cell_renderer_calc_offset (cell, cell_area, gtk_widget_get_direction (widget),
|
2010-11-09 13:15:06 +00:00
|
|
|
|
request.width, request.height, x_offset, y_offset);
|
2000-10-05 01:04:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-08-22 01:53:45 +00:00
|
|
|
|
/**
|
2010-09-11 01:50:47 +00:00
|
|
|
|
* gtk_cell_renderer_render:
|
2010-08-22 01:53:45 +00:00
|
|
|
|
* @cell: a #GtkCellRenderer
|
|
|
|
|
* @cr: a cairo context to draw to
|
|
|
|
|
* @widget: the widget owning @window
|
|
|
|
|
* @background_area: entire cell area (including tree expanders and maybe
|
|
|
|
|
* padding on the sides)
|
|
|
|
|
* @cell_area: area normally rendered by a cell renderer
|
|
|
|
|
* @flags: flags that affect rendering
|
|
|
|
|
*
|
|
|
|
|
* Invokes 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 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.
|
|
|
|
|
**/
|
|
|
|
|
void
|
2010-09-11 01:50:47 +00:00
|
|
|
|
gtk_cell_renderer_render (GtkCellRenderer *cell,
|
|
|
|
|
cairo_t *cr,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
const GdkRectangle *background_area,
|
|
|
|
|
const GdkRectangle *cell_area,
|
|
|
|
|
GtkCellRendererState flags)
|
2010-08-22 01:53:45 +00:00
|
|
|
|
{
|
|
|
|
|
gboolean selected = FALSE;
|
|
|
|
|
GtkCellRendererPrivate *priv = cell->priv;
|
2011-01-23 13:31:19 +00:00
|
|
|
|
GtkStyleContext *context;
|
|
|
|
|
GtkStateFlags state;
|
2010-08-22 01:53:45 +00:00
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
g_return_if_fail (GTK_CELL_RENDERER_GET_CLASS (cell)->render != NULL);
|
|
|
|
|
g_return_if_fail (cr != NULL);
|
|
|
|
|
|
|
|
|
|
selected = (flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED;
|
|
|
|
|
|
|
|
|
|
cairo_save (cr);
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
if (priv->cell_background_set && !selected)
|
2002-04-23 16:39:01 +00:00
|
|
|
|
{
|
2005-05-11 19:16:19 +00:00
|
|
|
|
gdk_cairo_rectangle (cr, background_area);
|
2010-10-22 16:07:08 +00:00
|
|
|
|
gdk_cairo_set_source_rgba (cr, &priv->cell_background);
|
2005-05-11 19:16:19 +00:00
|
|
|
|
cairo_fill (cr);
|
2002-04-23 16:39:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-12-15 23:07:08 +00:00
|
|
|
|
gdk_cairo_rectangle (cr, background_area);
|
|
|
|
|
cairo_clip (cr);
|
|
|
|
|
|
2011-01-23 13:31:19 +00:00
|
|
|
|
context = gtk_widget_get_style_context (widget);
|
|
|
|
|
|
|
|
|
|
gtk_style_context_save (context);
|
|
|
|
|
gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
|
|
|
|
|
|
|
|
|
|
state = gtk_cell_renderer_get_state (cell, widget, flags);
|
|
|
|
|
gtk_style_context_set_state (context, state);
|
|
|
|
|
|
2000-10-05 01:04:57 +00:00
|
|
|
|
GTK_CELL_RENDERER_GET_CLASS (cell)->render (cell,
|
2010-08-21 11:18:14 +00:00
|
|
|
|
cr,
|
2000-10-05 01:04:57 +00:00
|
|
|
|
widget,
|
2010-08-21 11:18:14 +00:00
|
|
|
|
background_area,
|
|
|
|
|
cell_area,
|
2000-10-05 01:04:57 +00:00
|
|
|
|
flags);
|
2011-01-23 13:31:19 +00:00
|
|
|
|
gtk_style_context_restore (context);
|
2010-08-22 01:53:45 +00:00
|
|
|
|
cairo_restore (cr);
|
2000-10-05 01:04:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
2001-02-03 01:09:41 +00:00
|
|
|
|
/**
|
2001-09-17 21:44:20 +00:00
|
|
|
|
* gtk_cell_renderer_activate:
|
2001-02-03 01:09:41 +00:00
|
|
|
|
* @cell: a #GtkCellRenderer
|
|
|
|
|
* @event: a #GdkEvent
|
|
|
|
|
* @widget: widget that received the event
|
2007-07-12 01:55:15 +00:00
|
|
|
|
* @path: widget-dependent string representation of the event location;
|
|
|
|
|
* e.g. for #GtkTreeView, a string representation of #GtkTreePath
|
|
|
|
|
* @background_area: background area as passed to gtk_cell_renderer_render()
|
|
|
|
|
* @cell_area: cell area as passed to gtk_cell_renderer_render()
|
2001-02-03 01:09:41 +00:00
|
|
|
|
* @flags: render flags
|
2001-03-15 23:21:39 +00:00
|
|
|
|
*
|
2007-07-12 01:55:15 +00:00
|
|
|
|
* 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.
|
2001-03-15 23:21:39 +00:00
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: %TRUE if the event was consumed/handled
|
2001-02-03 01:09:41 +00:00
|
|
|
|
**/
|
2001-03-28 04:01:21 +00:00
|
|
|
|
gboolean
|
2001-09-17 21:44:20 +00:00
|
|
|
|
gtk_cell_renderer_activate (GtkCellRenderer *cell,
|
|
|
|
|
GdkEvent *event,
|
|
|
|
|
GtkWidget *widget,
|
2001-10-31 10:27:17 +00:00
|
|
|
|
const gchar *path,
|
2008-01-25 09:30:40 +00:00
|
|
|
|
const GdkRectangle *background_area,
|
|
|
|
|
const GdkRectangle *cell_area,
|
2001-09-17 21:44:20 +00:00
|
|
|
|
GtkCellRendererState flags)
|
2000-10-05 01:04:57 +00:00
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2010-05-30 20:21:33 +00:00
|
|
|
|
|
2000-10-05 01:04:57 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
|
2001-09-17 21:44:20 +00:00
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
|
|
|
|
if (priv->mode != GTK_CELL_RENDERER_MODE_ACTIVATABLE)
|
2000-10-05 01:04:57 +00:00
|
|
|
|
return FALSE;
|
|
|
|
|
|
2001-09-17 21:44:20 +00:00
|
|
|
|
if (GTK_CELL_RENDERER_GET_CLASS (cell)->activate == NULL)
|
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
|
|
return GTK_CELL_RENDERER_GET_CLASS (cell)->activate (cell,
|
|
|
|
|
event,
|
|
|
|
|
widget,
|
|
|
|
|
path,
|
2008-01-25 09:30:40 +00:00
|
|
|
|
(GdkRectangle *) background_area,
|
|
|
|
|
(GdkRectangle *) cell_area,
|
2001-09-17 21:44:20 +00:00
|
|
|
|
flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_start_editing:
|
|
|
|
|
* @cell: a #GtkCellRenderer
|
2016-09-22 11:56:47 +00:00
|
|
|
|
* @event: (nullable): a #GdkEvent
|
2001-09-17 21:44:20 +00:00
|
|
|
|
* @widget: widget that received the event
|
2010-09-21 04:18:11 +00:00
|
|
|
|
* @path: widget-dependent string representation of the event location;
|
2007-07-12 01:55:15 +00:00
|
|
|
|
* e.g. for #GtkTreeView, a string representation of #GtkTreePath
|
|
|
|
|
* @background_area: background area as passed to gtk_cell_renderer_render()
|
|
|
|
|
* @cell_area: cell area as passed to gtk_cell_renderer_render()
|
2001-09-17 21:44:20 +00:00
|
|
|
|
* @flags: render flags
|
2010-09-21 04:18:11 +00:00
|
|
|
|
*
|
2018-04-02 12:18:18 +00:00
|
|
|
|
* Starts editing the contents of this @cell, through a new #GtkCellEditable
|
|
|
|
|
* widget created by the #GtkCellRendererClass.start_editing virtual function.
|
2010-09-21 04:18:11 +00:00
|
|
|
|
*
|
2018-04-02 12:18:18 +00:00
|
|
|
|
* Returns: (nullable) (transfer none): A new #GtkCellEditable for editing this
|
|
|
|
|
* @cell, or %NULL if editing is not possible
|
2001-09-17 21:44:20 +00:00
|
|
|
|
**/
|
|
|
|
|
GtkCellEditable *
|
|
|
|
|
gtk_cell_renderer_start_editing (GtkCellRenderer *cell,
|
|
|
|
|
GdkEvent *event,
|
|
|
|
|
GtkWidget *widget,
|
2001-10-31 10:27:17 +00:00
|
|
|
|
const gchar *path,
|
2008-01-25 09:30:40 +00:00
|
|
|
|
const GdkRectangle *background_area,
|
|
|
|
|
const GdkRectangle *cell_area,
|
2001-09-17 21:44:20 +00:00
|
|
|
|
GtkCellRendererState flags)
|
|
|
|
|
|
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2004-07-20 16:06:02 +00:00
|
|
|
|
GtkCellEditable *editable;
|
|
|
|
|
|
2001-09-17 21:44:20 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), NULL);
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
|
|
|
|
if (priv->mode != GTK_CELL_RENDERER_MODE_EDITABLE)
|
2001-09-17 21:44:20 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
if (GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2004-07-20 16:06:02 +00:00
|
|
|
|
editable = GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing (cell,
|
|
|
|
|
event,
|
|
|
|
|
widget,
|
|
|
|
|
path,
|
2008-01-25 09:30:40 +00:00
|
|
|
|
(GdkRectangle *) background_area,
|
|
|
|
|
(GdkRectangle *) cell_area,
|
2004-07-20 16:06:02 +00:00
|
|
|
|
flags);
|
2013-12-16 19:31:50 +00:00
|
|
|
|
if (editable == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2012-01-30 22:52:44 +00:00
|
|
|
|
gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (editable)),
|
|
|
|
|
GTK_STYLE_CLASS_CELL);
|
2004-07-20 16:06:02 +00:00
|
|
|
|
|
|
|
|
|
g_signal_emit (cell,
|
|
|
|
|
cell_renderer_signals[EDITING_STARTED], 0,
|
|
|
|
|
editable, path);
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv->editing = TRUE;
|
2004-12-09 17:55:58 +00:00
|
|
|
|
|
2004-07-20 16:06:02 +00:00
|
|
|
|
return editable;
|
2000-10-05 01:04:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
2001-06-30 02:38:17 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_set_fixed_size:
|
|
|
|
|
* @cell: A #GtkCellRenderer
|
|
|
|
|
* @width: the width of the cell renderer, or -1
|
|
|
|
|
* @height: the height of the cell renderer, or -1
|
2009-07-13 23:45:03 +00:00
|
|
|
|
*
|
2001-06-30 02:38:17 +00:00
|
|
|
|
* Sets the renderer size to be explicit, independent of the properties set.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell,
|
|
|
|
|
gint width,
|
|
|
|
|
gint height)
|
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2010-05-30 20:21:33 +00:00
|
|
|
|
|
2001-06-30 02:38:17 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
g_return_if_fail (width >= -1 && height >= -1);
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
|
|
|
|
if ((width != priv->width) || (height != priv->height))
|
2001-06-30 02:38:17 +00:00
|
|
|
|
{
|
coalescing property notifies
2001-08-11 Hans Breuer <hans@breuer.org>
* gtk/gtkalignment.c, gtk/gtkarrow.c, gtk/gtkaspectframe.c,
gtk/gtkcellrenderer.c, gtk/gtkcellrenderertext.c,
gtk/gtkcombo.c, gtk/gtkcurve.c, gtk/gtkfontsel.c,
gtk/gtklayout.c, gtk/gtkmisc.c, gtk/gtkpacker.c,
gtk/gtkprogress.c, gtk/gtkruler.c,, gtk/gtksettings.c,
gtk/gtkspinbutton.c, gtk/gtktexttag.c : coalescing property notifies
* gtk/gtkclist.c, gtk/gtktipsquery.c, gtk/gtktexttag.c,
gtk/gtkwidget.c : added G_SIGNAL_TYPE_STATIC_SCOPE to all
GDK_TYPE_EVENT signals
* gtk/gtkalignment.c : removed 'direct allocation bug',
which Tim discovered while reading the patch
2001-08-11 20:27:36 +00:00
|
|
|
|
g_object_freeze_notify (G_OBJECT (cell));
|
2001-06-30 02:38:17 +00:00
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
if (width != priv->width)
|
coalescing property notifies
2001-08-11 Hans Breuer <hans@breuer.org>
* gtk/gtkalignment.c, gtk/gtkarrow.c, gtk/gtkaspectframe.c,
gtk/gtkcellrenderer.c, gtk/gtkcellrenderertext.c,
gtk/gtkcombo.c, gtk/gtkcurve.c, gtk/gtkfontsel.c,
gtk/gtklayout.c, gtk/gtkmisc.c, gtk/gtkpacker.c,
gtk/gtkprogress.c, gtk/gtkruler.c,, gtk/gtksettings.c,
gtk/gtkspinbutton.c, gtk/gtktexttag.c : coalescing property notifies
* gtk/gtkclist.c, gtk/gtktipsquery.c, gtk/gtktexttag.c,
gtk/gtkwidget.c : added G_SIGNAL_TYPE_STATIC_SCOPE to all
GDK_TYPE_EVENT signals
* gtk/gtkalignment.c : removed 'direct allocation bug',
which Tim discovered while reading the patch
2001-08-11 20:27:36 +00:00
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv->width = width;
|
coalescing property notifies
2001-08-11 Hans Breuer <hans@breuer.org>
* gtk/gtkalignment.c, gtk/gtkarrow.c, gtk/gtkaspectframe.c,
gtk/gtkcellrenderer.c, gtk/gtkcellrenderertext.c,
gtk/gtkcombo.c, gtk/gtkcurve.c, gtk/gtkfontsel.c,
gtk/gtklayout.c, gtk/gtkmisc.c, gtk/gtkpacker.c,
gtk/gtkprogress.c, gtk/gtkruler.c,, gtk/gtksettings.c,
gtk/gtkspinbutton.c, gtk/gtktexttag.c : coalescing property notifies
* gtk/gtkclist.c, gtk/gtktipsquery.c, gtk/gtktexttag.c,
gtk/gtkwidget.c : added G_SIGNAL_TYPE_STATIC_SCOPE to all
GDK_TYPE_EVENT signals
* gtk/gtkalignment.c : removed 'direct allocation bug',
which Tim discovered while reading the patch
2001-08-11 20:27:36 +00:00
|
|
|
|
g_object_notify (G_OBJECT (cell), "width");
|
|
|
|
|
}
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
if (height != priv->height)
|
coalescing property notifies
2001-08-11 Hans Breuer <hans@breuer.org>
* gtk/gtkalignment.c, gtk/gtkarrow.c, gtk/gtkaspectframe.c,
gtk/gtkcellrenderer.c, gtk/gtkcellrenderertext.c,
gtk/gtkcombo.c, gtk/gtkcurve.c, gtk/gtkfontsel.c,
gtk/gtklayout.c, gtk/gtkmisc.c, gtk/gtkpacker.c,
gtk/gtkprogress.c, gtk/gtkruler.c,, gtk/gtksettings.c,
gtk/gtkspinbutton.c, gtk/gtktexttag.c : coalescing property notifies
* gtk/gtkclist.c, gtk/gtktipsquery.c, gtk/gtktexttag.c,
gtk/gtkwidget.c : added G_SIGNAL_TYPE_STATIC_SCOPE to all
GDK_TYPE_EVENT signals
* gtk/gtkalignment.c : removed 'direct allocation bug',
which Tim discovered while reading the patch
2001-08-11 20:27:36 +00:00
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv->height = height;
|
coalescing property notifies
2001-08-11 Hans Breuer <hans@breuer.org>
* gtk/gtkalignment.c, gtk/gtkarrow.c, gtk/gtkaspectframe.c,
gtk/gtkcellrenderer.c, gtk/gtkcellrenderertext.c,
gtk/gtkcombo.c, gtk/gtkcurve.c, gtk/gtkfontsel.c,
gtk/gtklayout.c, gtk/gtkmisc.c, gtk/gtkpacker.c,
gtk/gtkprogress.c, gtk/gtkruler.c,, gtk/gtksettings.c,
gtk/gtkspinbutton.c, gtk/gtktexttag.c : coalescing property notifies
* gtk/gtkclist.c, gtk/gtktipsquery.c, gtk/gtktexttag.c,
gtk/gtkwidget.c : added G_SIGNAL_TYPE_STATIC_SCOPE to all
GDK_TYPE_EVENT signals
* gtk/gtkalignment.c : removed 'direct allocation bug',
which Tim discovered while reading the patch
2001-08-11 20:27:36 +00:00
|
|
|
|
g_object_notify (G_OBJECT (cell), "height");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
g_object_thaw_notify (G_OBJECT (cell));
|
2001-06-30 02:38:17 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_fixed_size:
|
|
|
|
|
* @cell: A #GtkCellRenderer
|
2011-01-18 09:10:30 +00:00
|
|
|
|
* @width: (out) (allow-none): location to fill in with the fixed width of the cell, or %NULL
|
|
|
|
|
* @height: (out) (allow-none): location to fill in with the fixed height of the cell, or %NULL
|
2009-07-13 23:45:03 +00:00
|
|
|
|
*
|
2001-06-30 02:38:17 +00:00
|
|
|
|
* Fills in @width and @height with the appropriate size of @cell.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell,
|
|
|
|
|
gint *width,
|
|
|
|
|
gint *height)
|
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2010-05-30 20:21:33 +00:00
|
|
|
|
|
2001-06-30 02:38:17 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
2001-06-30 02:38:17 +00:00
|
|
|
|
if (width)
|
2010-05-30 20:21:33 +00:00
|
|
|
|
*width = priv->width;
|
2001-06-30 02:38:17 +00:00
|
|
|
|
if (height)
|
2010-05-30 20:21:33 +00:00
|
|
|
|
*height = priv->height;
|
2009-07-13 23:45:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_set_alignment:
|
|
|
|
|
* @cell: A #GtkCellRenderer
|
|
|
|
|
* @xalign: the x alignment of the cell renderer
|
|
|
|
|
* @yalign: the y alignment of the cell renderer
|
|
|
|
|
*
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* Sets the renderer’s alignment within its available space.
|
2009-07-13 23:45:03 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 2.18
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_set_alignment (GtkCellRenderer *cell,
|
|
|
|
|
gfloat xalign,
|
|
|
|
|
gfloat yalign)
|
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2010-05-30 20:21:33 +00:00
|
|
|
|
|
2009-07-13 23:45:03 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
g_return_if_fail (xalign >= 0.0 && xalign <= 1.0);
|
|
|
|
|
g_return_if_fail (yalign >= 0.0 && yalign <= 1.0);
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
|
|
|
|
if ((xalign != priv->xalign) || (yalign != priv->yalign))
|
2009-07-13 23:45:03 +00:00
|
|
|
|
{
|
|
|
|
|
g_object_freeze_notify (G_OBJECT (cell));
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
if (xalign != priv->xalign)
|
2009-07-13 23:45:03 +00:00
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv->xalign = xalign;
|
2009-07-13 23:45:03 +00:00
|
|
|
|
g_object_notify (G_OBJECT (cell), "xalign");
|
|
|
|
|
}
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
if (yalign != priv->yalign)
|
2009-07-13 23:45:03 +00:00
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv->yalign = yalign;
|
2009-07-13 23:45:03 +00:00
|
|
|
|
g_object_notify (G_OBJECT (cell), "yalign");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
g_object_thaw_notify (G_OBJECT (cell));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_alignment:
|
|
|
|
|
* @cell: A #GtkCellRenderer
|
2011-01-18 09:10:30 +00:00
|
|
|
|
* @xalign: (out) (allow-none): location to fill in with the x alignment of the cell, or %NULL
|
|
|
|
|
* @yalign: (out) (allow-none): location to fill in with the y alignment of the cell, or %NULL
|
2009-07-13 23:45:03 +00:00
|
|
|
|
*
|
|
|
|
|
* Fills in @xalign and @yalign with the appropriate values of @cell.
|
|
|
|
|
*
|
|
|
|
|
* Since: 2.18
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_get_alignment (GtkCellRenderer *cell,
|
|
|
|
|
gfloat *xalign,
|
|
|
|
|
gfloat *yalign)
|
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2010-05-30 20:21:33 +00:00
|
|
|
|
|
2009-07-13 23:45:03 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
2009-07-13 23:45:03 +00:00
|
|
|
|
if (xalign)
|
2010-05-30 20:21:33 +00:00
|
|
|
|
*xalign = priv->xalign;
|
2009-07-13 23:45:03 +00:00
|
|
|
|
if (yalign)
|
2010-05-30 20:21:33 +00:00
|
|
|
|
*yalign = priv->yalign;
|
2009-07-13 23:45:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_set_padding:
|
|
|
|
|
* @cell: A #GtkCellRenderer
|
|
|
|
|
* @xpad: the x padding of the cell renderer
|
|
|
|
|
* @ypad: the y padding of the cell renderer
|
|
|
|
|
*
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* Sets the renderer’s padding.
|
2009-07-13 23:45:03 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 2.18
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_set_padding (GtkCellRenderer *cell,
|
|
|
|
|
gint xpad,
|
|
|
|
|
gint ypad)
|
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2010-05-30 20:21:33 +00:00
|
|
|
|
|
2009-07-13 23:45:03 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
2015-01-11 15:01:40 +00:00
|
|
|
|
g_return_if_fail (xpad >= 0 && ypad >= 0);
|
2009-07-13 23:45:03 +00:00
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
|
|
|
|
if ((xpad != priv->xpad) || (ypad != priv->ypad))
|
2009-07-13 23:45:03 +00:00
|
|
|
|
{
|
|
|
|
|
g_object_freeze_notify (G_OBJECT (cell));
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
if (xpad != priv->xpad)
|
2009-07-13 23:45:03 +00:00
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv->xpad = xpad;
|
2009-07-13 23:45:03 +00:00
|
|
|
|
g_object_notify (G_OBJECT (cell), "xpad");
|
|
|
|
|
}
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
if (ypad != priv->ypad)
|
2009-07-13 23:45:03 +00:00
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv->ypad = ypad;
|
2009-07-13 23:45:03 +00:00
|
|
|
|
g_object_notify (G_OBJECT (cell), "ypad");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
g_object_thaw_notify (G_OBJECT (cell));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_padding:
|
|
|
|
|
* @cell: A #GtkCellRenderer
|
2011-01-18 09:10:30 +00:00
|
|
|
|
* @xpad: (out) (allow-none): location to fill in with the x padding of the cell, or %NULL
|
|
|
|
|
* @ypad: (out) (allow-none): location to fill in with the y padding of the cell, or %NULL
|
2009-07-13 23:45:03 +00:00
|
|
|
|
*
|
|
|
|
|
* Fills in @xpad and @ypad with the appropriate values of @cell.
|
|
|
|
|
*
|
|
|
|
|
* Since: 2.18
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_get_padding (GtkCellRenderer *cell,
|
|
|
|
|
gint *xpad,
|
|
|
|
|
gint *ypad)
|
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2010-05-30 20:21:33 +00:00
|
|
|
|
|
2009-07-13 23:45:03 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
2009-07-13 23:45:03 +00:00
|
|
|
|
if (xpad)
|
2010-05-30 20:21:33 +00:00
|
|
|
|
*xpad = priv->xpad;
|
2009-07-13 23:45:03 +00:00
|
|
|
|
if (ypad)
|
2010-05-30 20:21:33 +00:00
|
|
|
|
*ypad = priv->ypad;
|
2009-07-13 23:45:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
2009-07-15 01:22:22 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_set_visible:
|
|
|
|
|
* @cell: A #GtkCellRenderer
|
|
|
|
|
* @visible: the visibility of the cell
|
|
|
|
|
*
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* Sets the cell renderer’s visibility.
|
2009-07-15 01:22:22 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 2.18
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_set_visible (GtkCellRenderer *cell,
|
|
|
|
|
gboolean visible)
|
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2010-05-30 20:21:33 +00:00
|
|
|
|
|
2009-07-15 01:22:22 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
|
|
|
|
if (priv->visible != visible)
|
2009-07-15 01:22:22 +00:00
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv->visible = visible ? TRUE : FALSE;
|
2009-07-15 01:22:22 +00:00
|
|
|
|
g_object_notify (G_OBJECT (cell), "visible");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_visible:
|
|
|
|
|
* @cell: A #GtkCellRenderer
|
|
|
|
|
*
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* Returns the cell renderer’s visibility.
|
2009-07-15 01:22:22 +00:00
|
|
|
|
*
|
2009-08-24 22:17:54 +00:00
|
|
|
|
* Returns: %TRUE if the cell renderer is visible
|
|
|
|
|
*
|
2009-07-15 01:22:22 +00:00
|
|
|
|
* Since: 2.18
|
2009-08-24 22:17:54 +00:00
|
|
|
|
*/
|
2009-07-15 01:22:22 +00:00
|
|
|
|
gboolean
|
2009-08-24 22:17:54 +00:00
|
|
|
|
gtk_cell_renderer_get_visible (GtkCellRenderer *cell)
|
2009-07-15 01:22:22 +00:00
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
return cell->priv->visible;
|
2009-07-15 01:22:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2009-07-13 23:45:03 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_set_sensitive:
|
|
|
|
|
* @cell: A #GtkCellRenderer
|
|
|
|
|
* @sensitive: the sensitivity of the cell
|
|
|
|
|
*
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* Sets the cell renderer’s sensitivity.
|
2009-07-13 23:45:03 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 2.18
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_set_sensitive (GtkCellRenderer *cell,
|
|
|
|
|
gboolean sensitive)
|
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2010-05-30 20:21:33 +00:00
|
|
|
|
|
2009-07-13 23:45:03 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
|
|
|
|
if (priv->sensitive != sensitive)
|
2009-07-13 23:45:03 +00:00
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv->sensitive = sensitive ? TRUE : FALSE;
|
2009-07-13 23:45:03 +00:00
|
|
|
|
g_object_notify (G_OBJECT (cell), "sensitive");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_sensitive:
|
|
|
|
|
* @cell: A #GtkCellRenderer
|
|
|
|
|
*
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* Returns the cell renderer’s sensitivity.
|
2009-07-13 23:45:03 +00:00
|
|
|
|
*
|
2009-08-24 22:17:54 +00:00
|
|
|
|
* Returns: %TRUE if the cell renderer is sensitive
|
|
|
|
|
*
|
2009-07-13 23:45:03 +00:00
|
|
|
|
* Since: 2.18
|
2009-08-24 22:17:54 +00:00
|
|
|
|
*/
|
2009-07-13 23:45:03 +00:00
|
|
|
|
gboolean
|
2009-08-24 22:17:54 +00:00
|
|
|
|
gtk_cell_renderer_get_sensitive (GtkCellRenderer *cell)
|
2009-07-13 23:45:03 +00:00
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
return cell->priv->sensitive;
|
2001-06-30 02:38:17 +00:00
|
|
|
|
}
|
2004-01-16 19:18:28 +00:00
|
|
|
|
|
2010-11-05 04:05:20 +00:00
|
|
|
|
|
|
|
|
|
/**
|
2010-11-29 07:29:09 +00:00
|
|
|
|
* gtk_cell_renderer_is_activatable:
|
2010-11-05 04:05:20 +00:00
|
|
|
|
* @cell: A #GtkCellRenderer
|
|
|
|
|
*
|
2010-11-29 07:29:09 +00:00
|
|
|
|
* Checks whether the cell renderer can do something when activated.
|
2010-11-05 04:05:20 +00:00
|
|
|
|
*
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* Returns: %TRUE if the cell renderer can do anything when activated
|
2010-11-05 04:05:20 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.0
|
|
|
|
|
*/
|
|
|
|
|
gboolean
|
2010-11-29 07:29:09 +00:00
|
|
|
|
gtk_cell_renderer_is_activatable (GtkCellRenderer *cell)
|
2010-11-05 04:05:20 +00:00
|
|
|
|
{
|
|
|
|
|
GtkCellRendererPrivate *priv;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
|
|
|
|
|
|
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
2011-01-24 02:50:39 +00:00
|
|
|
|
return (priv->visible &&
|
|
|
|
|
(priv->mode == GTK_CELL_RENDERER_MODE_EDITABLE ||
|
|
|
|
|
priv->mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE));
|
2010-11-05 04:05:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-12-09 17:55:58 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_stop_editing:
|
|
|
|
|
* @cell: A #GtkCellRenderer
|
|
|
|
|
* @canceled: %TRUE if the editing has been canceled
|
|
|
|
|
*
|
|
|
|
|
* Informs the cell renderer that the editing is stopped.
|
2007-07-12 01:55:15 +00:00
|
|
|
|
* 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.
|
2004-12-09 17:55:58 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 2.6
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_stop_editing (GtkCellRenderer *cell,
|
|
|
|
|
gboolean canceled)
|
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2010-05-30 20:21:33 +00:00
|
|
|
|
|
2004-12-09 17:55:58 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
|
|
|
|
if (priv->editing)
|
2004-12-09 17:55:58 +00:00
|
|
|
|
{
|
2010-05-30 20:21:33 +00:00
|
|
|
|
priv->editing = FALSE;
|
2004-12-09 17:55:58 +00:00
|
|
|
|
if (canceled)
|
|
|
|
|
g_signal_emit (cell, cell_renderer_signals[EDITING_CANCELED], 0);
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-08-18 23:36:51 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2010-09-21 14:52:59 +00:00
|
|
|
|
gtk_cell_renderer_real_get_preferred_size (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
GtkOrientation orientation,
|
|
|
|
|
gint *minimum_size,
|
|
|
|
|
gint *natural_size)
|
2010-08-18 23:36:51 +00:00
|
|
|
|
{
|
|
|
|
|
GtkRequisition min_req;
|
|
|
|
|
|
|
|
|
|
/* Fallback on the old API to get the size. */
|
|
|
|
|
if (GTK_CELL_RENDERER_GET_CLASS (cell)->get_size)
|
|
|
|
|
GTK_CELL_RENDERER_GET_CLASS (cell)->get_size (GTK_CELL_RENDERER (cell), widget, NULL, NULL, NULL,
|
|
|
|
|
&min_req.width, &min_req.height);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
min_req.width = 0;
|
|
|
|
|
min_req.height = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (orientation == GTK_ORIENTATION_HORIZONTAL)
|
|
|
|
|
{
|
|
|
|
|
if (minimum_size)
|
|
|
|
|
*minimum_size = min_req.width;
|
|
|
|
|
|
|
|
|
|
if (natural_size)
|
|
|
|
|
*natural_size = min_req.width;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (minimum_size)
|
|
|
|
|
*minimum_size = min_req.height;
|
|
|
|
|
|
|
|
|
|
if (natural_size)
|
|
|
|
|
*natural_size = min_req.height;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-03 10:01:55 +00:00
|
|
|
|
static GtkSizeRequestMode
|
|
|
|
|
gtk_cell_renderer_real_get_request_mode (GtkCellRenderer *cell)
|
|
|
|
|
{
|
|
|
|
|
/* By default cell renderers are height-for-width. */
|
|
|
|
|
return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-18 23:36:51 +00:00
|
|
|
|
static void
|
2010-09-21 14:52:59 +00:00
|
|
|
|
gtk_cell_renderer_real_get_preferred_width (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
gint *minimum_size,
|
|
|
|
|
gint *natural_size)
|
2010-08-18 23:36:51 +00:00
|
|
|
|
{
|
2010-09-21 14:52:59 +00:00
|
|
|
|
gtk_cell_renderer_real_get_preferred_size (cell, widget, GTK_ORIENTATION_HORIZONTAL,
|
|
|
|
|
minimum_size, natural_size);
|
2010-08-18 23:36:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2010-09-21 14:52:59 +00:00
|
|
|
|
gtk_cell_renderer_real_get_preferred_height (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
gint *minimum_size,
|
|
|
|
|
gint *natural_size)
|
2010-08-18 23:36:51 +00:00
|
|
|
|
{
|
2010-09-21 14:52:59 +00:00
|
|
|
|
gtk_cell_renderer_real_get_preferred_size (cell, widget, GTK_ORIENTATION_VERTICAL,
|
|
|
|
|
minimum_size, natural_size);
|
2010-08-18 23:36:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2010-09-21 14:52:59 +00:00
|
|
|
|
gtk_cell_renderer_real_get_preferred_height_for_width (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
gint width,
|
|
|
|
|
gint *minimum_height,
|
|
|
|
|
gint *natural_height)
|
2010-08-18 23:36:51 +00:00
|
|
|
|
{
|
|
|
|
|
/* Fall back on the height reported from ->get_size() */
|
2010-09-21 14:52:59 +00:00
|
|
|
|
gtk_cell_renderer_get_preferred_height (cell, widget, minimum_height, natural_height);
|
2010-08-18 23:36:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2010-09-21 14:52:59 +00:00
|
|
|
|
gtk_cell_renderer_real_get_preferred_width_for_height (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
gint height,
|
|
|
|
|
gint *minimum_width,
|
|
|
|
|
gint *natural_width)
|
2010-08-18 23:36:51 +00:00
|
|
|
|
{
|
|
|
|
|
/* Fall back on the width reported from ->get_size() */
|
2010-09-21 14:52:59 +00:00
|
|
|
|
gtk_cell_renderer_get_preferred_width (cell, widget, minimum_width, natural_width);
|
2010-08-18 23:36:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-11-25 08:41:26 +00:00
|
|
|
|
|
|
|
|
|
/* Default implementation assumes that a cell renderer will never use more
|
2011-02-23 09:26:21 +00:00
|
|
|
|
* space than its natural size (this is fine for toggles and pixbufs etc
|
2010-11-25 08:41:26 +00:00
|
|
|
|
* but needs to be overridden from wrapping/ellipsizing text renderers) */
|
|
|
|
|
static void
|
|
|
|
|
gtk_cell_renderer_real_get_aligned_area (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
GtkCellRendererState flags,
|
|
|
|
|
const GdkRectangle *cell_area,
|
|
|
|
|
GdkRectangle *aligned_area)
|
|
|
|
|
{
|
|
|
|
|
gint opposite_size, x_offset, y_offset;
|
|
|
|
|
gint natural_size;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
|
|
|
|
g_return_if_fail (cell_area != NULL);
|
|
|
|
|
g_return_if_fail (aligned_area != NULL);
|
|
|
|
|
|
|
|
|
|
*aligned_area = *cell_area;
|
|
|
|
|
|
|
|
|
|
/* Trim up the aligned size */
|
|
|
|
|
if (gtk_cell_renderer_get_request_mode (cell) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
|
|
|
|
|
{
|
|
|
|
|
gtk_cell_renderer_get_preferred_width (cell, widget,
|
|
|
|
|
NULL, &natural_size);
|
|
|
|
|
|
|
|
|
|
aligned_area->width = MIN (aligned_area->width, natural_size);
|
|
|
|
|
|
|
|
|
|
gtk_cell_renderer_get_preferred_height_for_width (cell, widget,
|
|
|
|
|
aligned_area->width,
|
|
|
|
|
NULL, &opposite_size);
|
|
|
|
|
|
|
|
|
|
aligned_area->height = MIN (opposite_size, aligned_area->height);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
gtk_cell_renderer_get_preferred_height (cell, widget,
|
|
|
|
|
NULL, &natural_size);
|
|
|
|
|
|
|
|
|
|
aligned_area->height = MIN (aligned_area->width, natural_size);
|
|
|
|
|
|
|
|
|
|
gtk_cell_renderer_get_preferred_width_for_height (cell, widget,
|
|
|
|
|
aligned_area->height,
|
|
|
|
|
NULL, &opposite_size);
|
|
|
|
|
|
|
|
|
|
aligned_area->width = MIN (opposite_size, aligned_area->width);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* offset the cell position */
|
|
|
|
|
_gtk_cell_renderer_calc_offset (cell, cell_area,
|
|
|
|
|
gtk_widget_get_direction (widget),
|
|
|
|
|
aligned_area->width,
|
|
|
|
|
aligned_area->height,
|
|
|
|
|
&x_offset, &y_offset);
|
|
|
|
|
|
|
|
|
|
aligned_area->x += x_offset;
|
|
|
|
|
aligned_area->y += y_offset;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-08-18 23:36:51 +00:00
|
|
|
|
/* An internal convenience function for some containers to peek at the
|
|
|
|
|
* cell alignment in a target allocation (used to draw focus and align
|
|
|
|
|
* cells in the icon view).
|
|
|
|
|
*
|
2014-02-07 19:03:49 +00:00
|
|
|
|
* Note this is only a trivial “align * (allocation - request)” operation.
|
2010-08-18 23:36:51 +00:00
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
_gtk_cell_renderer_calc_offset (GtkCellRenderer *cell,
|
|
|
|
|
const GdkRectangle *cell_area,
|
|
|
|
|
GtkTextDirection direction,
|
|
|
|
|
gint width,
|
|
|
|
|
gint height,
|
|
|
|
|
gint *x_offset,
|
|
|
|
|
gint *y_offset)
|
|
|
|
|
{
|
2010-08-26 17:15:37 +00:00
|
|
|
|
GtkCellRendererPrivate *priv;
|
2010-08-18 23:36:51 +00:00
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
g_return_if_fail (cell_area != NULL);
|
|
|
|
|
g_return_if_fail (x_offset || y_offset);
|
|
|
|
|
|
|
|
|
|
priv = cell->priv;
|
|
|
|
|
|
|
|
|
|
if (x_offset)
|
|
|
|
|
{
|
|
|
|
|
*x_offset = (((direction == GTK_TEXT_DIR_RTL) ?
|
|
|
|
|
(1.0 - priv->xalign) : priv->xalign) *
|
|
|
|
|
(cell_area->width - width));
|
|
|
|
|
*x_offset = MAX (*x_offset, 0);
|
|
|
|
|
}
|
|
|
|
|
if (y_offset)
|
|
|
|
|
{
|
|
|
|
|
*y_offset = (priv->yalign *
|
|
|
|
|
(cell_area->height - height));
|
|
|
|
|
*y_offset = MAX (*y_offset, 0);
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-09-21 14:52:59 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_request_mode:
|
|
|
|
|
* @cell: a #GtkCellRenderer instance
|
|
|
|
|
*
|
|
|
|
|
* Gets whether the cell renderer prefers a height-for-width layout
|
|
|
|
|
* or a width-for-height layout.
|
|
|
|
|
*
|
|
|
|
|
* Returns: The #GtkSizeRequestMode preferred by this renderer.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.0
|
|
|
|
|
*/
|
|
|
|
|
GtkSizeRequestMode
|
|
|
|
|
gtk_cell_renderer_get_request_mode (GtkCellRenderer *cell)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
|
|
|
|
|
|
2011-02-03 10:01:55 +00:00
|
|
|
|
return GTK_CELL_RENDERER_GET_CLASS (cell)->get_request_mode (cell);
|
2010-09-21 14:52:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_preferred_width:
|
|
|
|
|
* @cell: a #GtkCellRenderer instance
|
|
|
|
|
* @widget: the #GtkWidget this cell will be rendering to
|
2011-01-18 09:10:30 +00:00
|
|
|
|
* @minimum_size: (out) (allow-none): location to store the minimum size, or %NULL
|
|
|
|
|
* @natural_size: (out) (allow-none): location to store the natural size, or %NULL
|
2010-09-21 14:52:59 +00:00
|
|
|
|
*
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* Retreives a renderer’s natural size when rendered to @widget.
|
2010-09-21 14:52:59 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.0
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_get_preferred_width (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
gint *minimum_size,
|
|
|
|
|
gint *natural_size)
|
|
|
|
|
{
|
|
|
|
|
GtkCellRendererClass *klass;
|
|
|
|
|
gint width;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
|
|
|
|
g_return_if_fail (NULL != minimum_size || NULL != natural_size);
|
|
|
|
|
|
|
|
|
|
gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), &width, NULL);
|
|
|
|
|
|
|
|
|
|
if (width < 0)
|
|
|
|
|
{
|
|
|
|
|
klass = GTK_CELL_RENDERER_GET_CLASS (cell);
|
|
|
|
|
klass->get_preferred_width (cell, widget, minimum_size, natural_size);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (minimum_size)
|
|
|
|
|
*minimum_size = width;
|
|
|
|
|
if (natural_size)
|
|
|
|
|
*natural_size = width;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if DEBUG_CELL_SIZE_REQUEST
|
|
|
|
|
g_message ("%s returning minimum width: %d and natural width: %d",
|
|
|
|
|
G_OBJECT_TYPE_NAME (cell),
|
|
|
|
|
minimum_size ? *minimum_size : 20000,
|
|
|
|
|
natural_size ? *natural_size : 20000);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_preferred_height:
|
|
|
|
|
* @cell: a #GtkCellRenderer instance
|
|
|
|
|
* @widget: the #GtkWidget this cell will be rendering to
|
2011-01-18 09:10:30 +00:00
|
|
|
|
* @minimum_size: (out) (allow-none): location to store the minimum size, or %NULL
|
|
|
|
|
* @natural_size: (out) (allow-none): location to store the natural size, or %NULL
|
2010-09-21 14:52:59 +00:00
|
|
|
|
*
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* Retreives a renderer’s natural size when rendered to @widget.
|
2010-09-21 14:52:59 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.0
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_get_preferred_height (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
gint *minimum_size,
|
|
|
|
|
gint *natural_size)
|
|
|
|
|
{
|
|
|
|
|
GtkCellRendererClass *klass;
|
|
|
|
|
gint height;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
|
|
|
|
g_return_if_fail (NULL != minimum_size || NULL != natural_size);
|
|
|
|
|
|
|
|
|
|
gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), NULL, &height);
|
|
|
|
|
|
|
|
|
|
if (height < 0)
|
|
|
|
|
{
|
|
|
|
|
klass = GTK_CELL_RENDERER_GET_CLASS (cell);
|
|
|
|
|
klass->get_preferred_height (cell, widget, minimum_size, natural_size);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (minimum_size)
|
|
|
|
|
*minimum_size = height;
|
|
|
|
|
if (natural_size)
|
|
|
|
|
*natural_size = height;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if DEBUG_CELL_SIZE_REQUEST
|
|
|
|
|
g_message ("%s returning minimum height: %d and natural height: %d",
|
|
|
|
|
G_OBJECT_TYPE_NAME (cell),
|
|
|
|
|
minimum_size ? *minimum_size : 20000,
|
|
|
|
|
natural_size ? *natural_size : 20000);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_preferred_width_for_height:
|
|
|
|
|
* @cell: a #GtkCellRenderer instance
|
|
|
|
|
* @widget: the #GtkWidget this cell will be rendering to
|
|
|
|
|
* @height: the size which is available for allocation
|
2011-01-18 09:10:30 +00:00
|
|
|
|
* @minimum_width: (out) (allow-none): location for storing the minimum size, or %NULL
|
|
|
|
|
* @natural_width: (out) (allow-none): location for storing the preferred size, or %NULL
|
2010-09-21 14:52:59 +00:00
|
|
|
|
*
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* Retreives a cell renderers’s minimum and natural width if it were rendered to
|
2010-09-21 14:52:59 +00:00
|
|
|
|
* @widget with the specified @height.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.0
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_get_preferred_width_for_height (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
gint height,
|
|
|
|
|
gint *minimum_width,
|
|
|
|
|
gint *natural_width)
|
|
|
|
|
{
|
|
|
|
|
GtkCellRendererClass *klass;
|
|
|
|
|
gint width;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
|
|
|
|
g_return_if_fail (NULL != minimum_width || NULL != natural_width);
|
|
|
|
|
|
|
|
|
|
gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), &width, NULL);
|
|
|
|
|
|
|
|
|
|
if (width < 0)
|
|
|
|
|
{
|
|
|
|
|
klass = GTK_CELL_RENDERER_GET_CLASS (cell);
|
|
|
|
|
klass->get_preferred_width_for_height (cell, widget, height, minimum_width, natural_width);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (minimum_width)
|
|
|
|
|
*minimum_width = width;
|
|
|
|
|
if (natural_width)
|
|
|
|
|
*natural_width = width;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if DEBUG_CELL_SIZE_REQUEST
|
|
|
|
|
g_message ("%s width for height: %d is minimum %d and natural: %d",
|
|
|
|
|
G_OBJECT_TYPE_NAME (cell), height,
|
|
|
|
|
minimum_width ? *minimum_width : 20000,
|
|
|
|
|
natural_width ? *natural_width : 20000);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_preferred_height_for_width:
|
|
|
|
|
* @cell: a #GtkCellRenderer instance
|
|
|
|
|
* @widget: the #GtkWidget this cell will be rendering to
|
|
|
|
|
* @width: the size which is available for allocation
|
2011-01-18 09:10:30 +00:00
|
|
|
|
* @minimum_height: (out) (allow-none): location for storing the minimum size, or %NULL
|
|
|
|
|
* @natural_height: (out) (allow-none): location for storing the preferred size, or %NULL
|
2010-09-21 14:52:59 +00:00
|
|
|
|
*
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* Retreives a cell renderers’s minimum and natural height if it were rendered to
|
2010-09-21 14:52:59 +00:00
|
|
|
|
* @widget with the specified @width.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.0
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_get_preferred_height_for_width (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
gint width,
|
|
|
|
|
gint *minimum_height,
|
|
|
|
|
gint *natural_height)
|
|
|
|
|
{
|
|
|
|
|
GtkCellRendererClass *klass;
|
|
|
|
|
gint height;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
|
|
|
|
g_return_if_fail (NULL != minimum_height || NULL != natural_height);
|
|
|
|
|
|
|
|
|
|
gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), NULL, &height);
|
|
|
|
|
|
|
|
|
|
if (height < 0)
|
|
|
|
|
{
|
|
|
|
|
klass = GTK_CELL_RENDERER_GET_CLASS (cell);
|
|
|
|
|
klass->get_preferred_height_for_width (cell, widget, width, minimum_height, natural_height);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (minimum_height)
|
|
|
|
|
*minimum_height = height;
|
|
|
|
|
if (natural_height)
|
|
|
|
|
*natural_height = height;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if DEBUG_CELL_SIZE_REQUEST
|
|
|
|
|
g_message ("%s height for width: %d is minimum %d and natural: %d",
|
|
|
|
|
G_OBJECT_TYPE_NAME (cell), width,
|
|
|
|
|
minimum_height ? *minimum_height : 20000,
|
|
|
|
|
natural_height ? *natural_height : 20000);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_preferred_size:
|
|
|
|
|
* @cell: a #GtkCellRenderer instance
|
|
|
|
|
* @widget: the #GtkWidget this cell will be rendering to
|
|
|
|
|
* @minimum_size: (out) (allow-none): location for storing the minimum size, or %NULL
|
|
|
|
|
* @natural_size: (out) (allow-none): location for storing the natural size, or %NULL
|
|
|
|
|
*
|
|
|
|
|
* Retrieves the minimum and natural size of a cell taking
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* into account the widget’s preference for height-for-width management.
|
2010-09-21 14:52:59 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.0
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_get_preferred_size (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
GtkRequisition *minimum_size,
|
|
|
|
|
GtkRequisition *natural_size)
|
|
|
|
|
{
|
|
|
|
|
gint min_width, nat_width;
|
|
|
|
|
gint min_height, nat_height;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
|
|
|
|
|
if (gtk_cell_renderer_get_request_mode (cell) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
|
|
|
|
|
{
|
|
|
|
|
gtk_cell_renderer_get_preferred_width (cell, widget, &min_width, &nat_width);
|
|
|
|
|
|
|
|
|
|
if (minimum_size)
|
|
|
|
|
{
|
|
|
|
|
minimum_size->width = min_width;
|
|
|
|
|
gtk_cell_renderer_get_preferred_height_for_width (cell, widget, min_width,
|
|
|
|
|
&minimum_size->height, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (natural_size)
|
|
|
|
|
{
|
|
|
|
|
natural_size->width = nat_width;
|
|
|
|
|
gtk_cell_renderer_get_preferred_height_for_width (cell, widget, nat_width,
|
|
|
|
|
NULL, &natural_size->height);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else /* GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT */
|
|
|
|
|
{
|
|
|
|
|
gtk_cell_renderer_get_preferred_height (cell, widget, &min_height, &nat_height);
|
|
|
|
|
|
|
|
|
|
if (minimum_size)
|
|
|
|
|
{
|
|
|
|
|
minimum_size->height = min_height;
|
|
|
|
|
gtk_cell_renderer_get_preferred_width_for_height (cell, widget, min_height,
|
|
|
|
|
&minimum_size->width, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (natural_size)
|
|
|
|
|
{
|
|
|
|
|
natural_size->height = nat_height;
|
|
|
|
|
gtk_cell_renderer_get_preferred_width_for_height (cell, widget, nat_height,
|
|
|
|
|
NULL, &natural_size->width);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-11-25 08:41:26 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_aligned_area:
|
|
|
|
|
* @cell: a #GtkCellRenderer instance
|
|
|
|
|
* @widget: the #GtkWidget this cell will be rendering to
|
|
|
|
|
* @flags: render flags
|
|
|
|
|
* @cell_area: cell area which would be passed to gtk_cell_renderer_render()
|
2011-01-18 09:10:30 +00:00
|
|
|
|
* @aligned_area: (out): the return location for the space inside @cell_area
|
|
|
|
|
* that would acually be used to render.
|
2010-11-25 08:41:26 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the aligned area used by @cell inside @cell_area. Used for finding
|
|
|
|
|
* the appropriate edit and focus rectangle.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.0
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gtk_cell_renderer_get_aligned_area (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
GtkCellRendererState flags,
|
|
|
|
|
const GdkRectangle *cell_area,
|
|
|
|
|
GdkRectangle *aligned_area)
|
|
|
|
|
{
|
|
|
|
|
GtkCellRendererClass *klass;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
|
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
|
|
|
|
g_return_if_fail (cell_area != NULL);
|
|
|
|
|
g_return_if_fail (aligned_area != NULL);
|
|
|
|
|
|
|
|
|
|
klass = GTK_CELL_RENDERER_GET_CLASS (cell);
|
|
|
|
|
klass->get_aligned_area (cell, widget, flags, cell_area, aligned_area);
|
2011-01-05 17:29:18 +00:00
|
|
|
|
|
2011-01-12 16:12:33 +00:00
|
|
|
|
g_assert (aligned_area->x >= cell_area->x && aligned_area->x <= cell_area->x + cell_area->width);
|
|
|
|
|
g_assert (aligned_area->y >= cell_area->y && aligned_area->y <= cell_area->y + cell_area->height);
|
2011-01-05 17:29:18 +00:00
|
|
|
|
g_assert ((aligned_area->x - cell_area->x) + aligned_area->width <= cell_area->width);
|
|
|
|
|
g_assert ((aligned_area->y - cell_area->y) + aligned_area->height <= cell_area->height);
|
2010-11-25 08:41:26 +00:00
|
|
|
|
}
|
2011-01-23 13:12:36 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_get_state:
|
2016-09-22 11:56:47 +00:00
|
|
|
|
* @cell: (nullable): a #GtkCellRenderer, or %NULL
|
|
|
|
|
* @widget: (nullable): a #GtkWidget, or %NULL
|
2011-01-23 13:12:36 +00:00
|
|
|
|
* @cell_state: cell renderer state
|
|
|
|
|
*
|
2011-01-28 09:10:23 +00:00
|
|
|
|
* Translates the cell renderer state to #GtkStateFlags,
|
2011-01-23 13:12:36 +00:00
|
|
|
|
* based on the cell renderer and widget sensitivity, and
|
2011-01-28 09:10:23 +00:00
|
|
|
|
* the given #GtkCellRendererState.
|
2011-01-23 13:12:36 +00:00
|
|
|
|
*
|
|
|
|
|
* Returns: the widget state flags applying to @cell
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.0
|
|
|
|
|
**/
|
|
|
|
|
GtkStateFlags
|
|
|
|
|
gtk_cell_renderer_get_state (GtkCellRenderer *cell,
|
|
|
|
|
GtkWidget *widget,
|
|
|
|
|
GtkCellRendererState cell_state)
|
|
|
|
|
{
|
|
|
|
|
GtkStateFlags state = 0;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (!cell || GTK_IS_CELL_RENDERER (cell), 0);
|
|
|
|
|
g_return_val_if_fail (!widget || GTK_IS_WIDGET (widget), 0);
|
|
|
|
|
|
2011-12-16 19:45:53 +00:00
|
|
|
|
if (widget)
|
|
|
|
|
state |= gtk_widget_get_state_flags (widget);
|
|
|
|
|
|
2016-03-01 20:18:34 +00:00
|
|
|
|
state &= ~(GTK_STATE_FLAG_FOCUSED | GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_SELECTED | GTK_STATE_FLAG_DROP_ACTIVE);
|
2011-12-16 19:45:53 +00:00
|
|
|
|
|
|
|
|
|
if ((state & GTK_STATE_FLAG_INSENSITIVE) != 0 ||
|
2011-02-06 01:51:20 +00:00
|
|
|
|
(cell && !gtk_cell_renderer_get_sensitive (cell)) ||
|
|
|
|
|
(cell_state & GTK_CELL_RENDERER_INSENSITIVE) != 0)
|
2011-02-06 13:43:55 +00:00
|
|
|
|
{
|
|
|
|
|
state |= GTK_STATE_FLAG_INSENSITIVE;
|
|
|
|
|
}
|
2011-01-23 13:12:36 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
2011-02-06 13:43:55 +00:00
|
|
|
|
if ((widget && gtk_widget_has_focus (widget)) &&
|
|
|
|
|
(cell_state & GTK_CELL_RENDERER_FOCUSED) != 0)
|
|
|
|
|
state |= GTK_STATE_FLAG_FOCUSED;
|
2011-01-23 13:12:36 +00:00
|
|
|
|
|
|
|
|
|
if ((cell_state & GTK_CELL_RENDERER_PRELIT) != 0)
|
|
|
|
|
state |= GTK_STATE_FLAG_PRELIGHT;
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-06 13:43:55 +00:00
|
|
|
|
if ((cell_state & GTK_CELL_RENDERER_SELECTED) != 0)
|
|
|
|
|
state |= GTK_STATE_FLAG_SELECTED;
|
|
|
|
|
|
2011-01-23 13:12:36 +00:00
|
|
|
|
return state;
|
|
|
|
|
}
|
2011-12-15 17:17:06 +00:00
|
|
|
|
|
2013-02-25 20:41:30 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_cell_renderer_class_set_accessible_type:
|
2011-12-15 17:17:06 +00:00
|
|
|
|
* @renderer_class: class to set the accessible type for
|
|
|
|
|
* @type: The object type that implements the accessible for @widget_class.
|
|
|
|
|
* The type must be a subtype of #GtkRendererCellAccessible
|
|
|
|
|
*
|
|
|
|
|
* Sets the type to be used for creating accessibles for cells rendered by
|
|
|
|
|
* cell renderers of @renderer_class. Note that multiple accessibles will
|
|
|
|
|
* be created.
|
|
|
|
|
*
|
|
|
|
|
* This function should only be called from class init functions of cell
|
|
|
|
|
* renderers.
|
|
|
|
|
**/
|
|
|
|
|
void
|
2013-02-25 20:41:30 +00:00
|
|
|
|
gtk_cell_renderer_class_set_accessible_type (GtkCellRendererClass *renderer_class,
|
|
|
|
|
GType type)
|
2011-12-15 17:17:06 +00:00
|
|
|
|
{
|
|
|
|
|
GtkCellRendererClassPrivate *priv;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER_CLASS (renderer_class));
|
|
|
|
|
g_return_if_fail (g_type_is_a (type, GTK_TYPE_RENDERER_CELL_ACCESSIBLE));
|
|
|
|
|
|
|
|
|
|
priv = renderer_class->priv;
|
|
|
|
|
|
|
|
|
|
priv->accessible_type = type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
GType
|
|
|
|
|
_gtk_cell_renderer_get_accessible_type (GtkCellRenderer *renderer)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), GTK_TYPE_RENDERER_CELL_ACCESSIBLE);
|
|
|
|
|
|
|
|
|
|
return GTK_CELL_RENDERER_GET_CLASS (renderer)->priv->accessible_type;
|
|
|
|
|
}
|
|
|
|
|
|