[gtk+] Trivial changes
- From: Matthias Clasen <matthiasc src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk+] Trivial changes
- Date: Sat, 18 Dec 2010 00:15:10 +0000 (UTC)
commit a2dda0c2bb88c1f009f7a10e0e344c4a301ff3b9
Author: Matthias Clasen <mclasen redhat com>
Date: Fri Dec 17 19:14:35 2010 -0500
Trivial changes
Whitespace fixes, comment formatting, etc
gtk/gtkcellarea.c | 1650 ++++++++++++++++++++++---------------------
gtk/gtkcellarea.h | 474 +++++++------
gtk/gtkcellareabox.c | 1302 +++++++++++++++++-----------------
gtk/gtkcellareabox.h | 34 +-
gtk/gtkcellareaboxcontext.c | 320 +++++-----
gtk/gtkcellareaboxcontext.h | 76 +-
gtk/gtkcellareacontext.c | 290 ++++----
gtk/gtkcellareacontext.h | 86 ++--
8 files changed, 2159 insertions(+), 2073 deletions(-)
---
diff --git a/gtk/gtkcellarea.c b/gtk/gtkcellarea.c
index 184ac50..40a5c9e 100644
--- a/gtk/gtkcellarea.c
+++ b/gtk/gtkcellarea.c
@@ -26,22 +26,23 @@
* @Short_Description: An abstract class for laying out GtkCellRenderers
* @Title: GtkCellArea
*
- * The #GtkCellArea is an abstract class for #GtkCellLayout widgets (also referred
- * to as "layouting widgets") to interface with an arbitrary number of #GtkCellRenderers
- * and interact with the user for a given #GtkTreeModel row.
+ * The #GtkCellArea is an abstract class for #GtkCellLayout widgets
+ * (also referred to as "layouting widgets") to interface with an
+ * arbitrary number of #GtkCellRenderers and interact with the user
+ * for a given #GtkTreeModel row.
*
- * The cell area handles events, focus navigation, drawing and wraps geometrical
+ * The cell area handles events, focus navigation, drawing and
* size requests and allocations for a given row of data.
*
- * Usually users dont have to interact with the #GtkCellArea directly unless they
- * are implementing a cell layouting widget themselves.
+ * Usually users dont have to interact with the #GtkCellArea directly
+ * unless they are implementing a cell layouting widget themselves.
*
* <refsect2 id="cell-area-geometry-management">
* <title>Requesting area sizes</title>
* <para>
* As outlined in <link linkend="geometry-management">GtkWidget's
* geometry management section</link>, GTK+ uses a height-for-width
- * geometry managemen system to compute the sizes of widgets and user
+ * geometry management system to compute the sizes of widgets and user
* interfaces. #GtkCellArea uses the same semantics to calculate the
* size of an area for an arbitrary number of #GtkTreeModel rows.
*
@@ -50,11 +51,11 @@
* different layouting widgets. For instance a #GtkTreeViewColumn
* always lines up the areas from top to bottom while a #GtkIconView
* on the other hand might enforce that all areas received the same
- * width and wrap the areas around, requesting height for more cell
+ * width and wrap the areas around, requesting height for more cell
* areas when allocated less width.
*
- * It's also important for areas to maintain some cell
- * alignments with areas rendered for adjacent rows (cells can
+ * It's also important for areas to maintain some cell
+ * alignments with areas rendered for adjacent rows (cells can
* appear "columnized" inside an area even when the size of
* cells are different in each row). For this reason the #GtkCellArea
* uses a #GtkCellAreaContext object to store the alignments
@@ -66,7 +67,7 @@
* #GtkCellArea which created it (see gtk_cell_area_create_context()).
* The owning cell layouting widget can create as many contexts as
* it wishes to calculate sizes of rows which should receive the
- * same size in at least one orientation (horizontally or vertically),
+ * same size in at least one orientation (horizontally or vertically),
* however it's important that the same #GtkCellAreaContext which
* was used to request the sizes for a given #GtkTreeModel row be
* used when rendering or processing events for that row.
@@ -74,7 +75,7 @@
* In order to request the width of all the rows at the root level
* of a #GtkTreeModel one would do the following:
* <example>
- * <title>Requesting the width of a hand full of GtkTreeModel rows.</title>
+ * <title>Requesting the width of a handful of GtkTreeModel rows</title>
* <programlisting>
* GtkTreeIter iter;
* gint minimum_width;
@@ -91,22 +92,26 @@
* gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width);
* </programlisting>
* </example>
- * Note that in this example it's not important to observe the returned minimum and
- * natural width of the area for each row unless the cell layouting object is actually
- * interested in the widths of individual rows. The overall width is however stored
- * in the accompanying #GtkCellAreaContext object and can be consulted at any time.
- *
- * This can be useful since #GtkCellLayout widgets usually have to support requesting
- * and rendering rows in treemodels with an exceedingly large amount of rows. The
- * #GtkCellLayout widget in that case would calculate the required width of the rows
- * in an idle or timeout source (see g_timeout_add()) and when the widget is requested
- * its actual width in #GtkWidgetClass.get_preferred_width() it can simply consult the
- * width accumulated so far in the #GtkCellAreaContext object.
- *
- * A simple example where rows are rendered from top to bottom and take up the full
- * width of the layouting widget would look like:
+ * Note that in this example it's not important to observe the
+ * returned minimum and natural width of the area for each row
+ * unless the cell layouting object is actually interested in the
+ * widths of individual rows. The overall width is however stored
+ * in the accompanying #GtkCellAreaContext object and can be consulted
+ * at any time.
+ *
+ * This can be useful since #GtkCellLayout widgets usually have to
+ * support requesting and rendering rows in treemodels with an
+ * exceedingly large amount of rows. The #GtkCellLayout widget in
+ * that case would calculate the required width of the rows in an
+ * idle or timeout source (see g_timeout_add()) and when the widget
+ * is requested its actual width in #GtkWidgetClass.get_preferred_width()
+ * it can simply consult the width accumulated so far in the
+ * #GtkCellAreaContext object.
+ *
+ * A simple example where rows are rendered from top to bottom and
+ * take up the full width of the layouting widget would look like:
* <example>
- * <title>A typical #GtkWidgetClass.get_preferred_width() for a layouting widget.</title>
+ * <title>A typical get_preferred_width() implementation</title>
* <programlisting>
* static void
* foo_get_preferred_width (GtkWidget *widget,
@@ -122,22 +127,23 @@
* }
* </programlisting>
* </example>
- *
- * In the above example the Foo widget has to make sure that some row sizes have
- * been calculated (the amount of rows that Foo judged was appropriate to request
- * space for in a single timeout iteration) before simply returning the amount
- * of space required by the area via the #GtkCellAreaContext.
- *
- * Requesting the height for width (or width for height) of an area is a similar
- * task except in this case the #GtkCellAreaContext does not store the data (actually
- * it does not know how much space the layouting widget plans to allocate it for
- * every row, it's up to the layouting widget to render each row of data with
- * the appropriate height and width which was requested by the #GtkCellArea).
- *
- * In order to request the height for width of all the rows at the root level
- * of a #GtkTreeModel one would do the following:
+ * In the above example the Foo widget has to make sure that some
+ * row sizes have been calculated (the amount of rows that Foo judged
+ * was appropriate to request space for in a single timeout iteration)
+ * before simply returning the amount of space required by the area via
+ * the #GtkCellAreaContext.
+ *
+ * Requesting the height for width (or width for height) of an area is
+ * a similar task except in this case the #GtkCellAreaContext does not
+ * store the data (actually, it does not know how much space the layouting
+ * widget plans to allocate it for every row, it's up to the layouting
+ * widget to render each row of data with the appropriate height and
+ * width which was requested by the #GtkCellArea).
+ *
+ * In order to request the height for width of all the rows at the
+ * root level of a #GtkTreeModel one would do the following:
* <example>
- * <title>Requesting the height for width of a hand full of GtkTreeModel rows.</title>
+ * <title>Requesting the height for width of a handful of GtkTreeModel rows</title>
* <programlisting>
* GtkTreeIter iter;
* gint minimum_height;
@@ -149,7 +155,7 @@
* while (valid)
* {
* gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
- * gtk_cell_area_get_preferred_height_for_width (area, context, widget,
+ * gtk_cell_area_get_preferred_height_for_width (area, context, widget,
* width, &minimum_height, &natural_height);
*
* if (width_is_for_allocation)
@@ -162,34 +168,39 @@
* }
* </programlisting>
* </example>
- *
- * Note that in the above example we would need to cache the heights returned for each
- * treemodel row so that we would know what sizes to render the areas for each row. However
- * we would only want to really cache the heights if the request is intended for the
- * layouting widgets real allocation.
- *
- * In some cases the layouting widget is requested the height for an arbitrary for_width,
- * this is a special case for layouting widgets who need to request size for tens of thousands
- * of treemodel rows. For this case it's only important that the layouting widget calculate
- * one reasonably sized chunk of rows and return that height synchronously. The reasoning here
- * is that any layouting widget is at least capable of synchronously calculating enough
- * height to fill the screen height (or scrolled window height) in response to a single call to
- * #GtkWidgetClass.get_preferred_height_for_width(). Returning a perfect height for width that
- * is larger than the screen area is inconsequential since after the layouting receives an
- * allocation from a scrolled window it simply continues to drive the the scrollbar
- * values while more and mode height is required for the row heights that are calculated
- * in the background.
+ * Note that in the above example we would need to cache the heights
+ * returned for each row so that we would know what sizes to render the
+ * areas for each row. However we would only want to really cache the
+ * heights if the request is intended for the layouting widgets real
+ * allocation.
+ *
+ * In some cases the layouting widget is requested the height for an
+ * arbitrary for_width, this is a special case for layouting widgets
+ * who need to request size for tens of thousands of rows. For this
+ * case it's only important that the layouting widget calculate
+ * one reasonably sized chunk of rows and return that height
+ * synchronously. The reasoning here is that any layouting widget is
+ * at least capable of synchronously calculating enough height to fill
+ * the screen height (or scrolled window height) in response to a single
+ * call to #GtkWidgetClass.get_preferred_height_for_width(). Returning
+ * a perfect height for width that is larger than the screen area is
+ * inconsequential since after the layouting receives an allocation
+ * from a scrolled window it simply continues to drive the the scrollbar
+ * values while more and more height is required for the row heights
+ * that are calculated in the background.
* </para>
* </refsect2>
* <refsect2 id="cell-area-rendering">
* <title>Rendering Areas</title>
* <para>
- * Once area sizes have been aquired at least for the rows in the visible area of the
- * layouting widget they can be rendered at #GtkWidgetClass.draw() time.
+ * Once area sizes have been aquired at least for the rows in the
+ * visible area of the layouting widget they can be rendered at
+ * #GtkWidgetClass.draw() time.
*
- * A crued example of how to render all the rows at the root level runs as follows:
+ * A crude example of how to render all the rows at the root level
+ * runs as follows:
* <example>
- * <title>Requesting the width of a hand full of GtkTreeModel rows.</title>
+ * <title>Requesting the width of a handful of GtkTreeModel rows</title>
* <programlisting>
* GtkAllocation allocation;
* GdkRectangle cell_area = { 0, };
@@ -206,7 +217,7 @@
* cell_area.height = get_cached_height_for_row (&iter);
*
* gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
- * gtk_cell_area_render (area, context, widget, cr,
+ * gtk_cell_area_render (area, context, widget, cr,
* &cell_area, &cell_area, state_flags, FALSE);
*
* cell_area.y += cell_area.height;
@@ -215,42 +226,46 @@
* }
* </programlisting>
* </example>
- * Note that the cached height in this example really depends on how the layouting
- * widget works. The layouting widget might decide to give every row it's minimum
- * or natural height or if the model content is expected to fit inside the layouting
- * widget with no scrolled window it would make sense to calculate the allocation
- * for each row at #GtkWidget.size_allocate() time using gtk_distribute_natural_allocation().
+ * Note that the cached height in this example really depends on how
+ * the layouting widget works. The layouting widget might decide to
+ * give every row it's minimum or natural height or, if the model content
+ * is expected to fit inside the layouting widget without scrolling, it
+ * would make sense to calculate the allocation for each row at
+ * #GtkWidget.size_allocate() time using gtk_distribute_natural_allocation().
* </para>
* </refsect2>
* <refsect2 id="cell-area-events-and-focus">
* <title>Handling Events and Driving Keyboard Focus</title>
* <para>
- * Passing events to the area is as simple as handling events on any normal
- * widget and then passing them to the gtk_cell_area_event() api as they come
- * in. Usually #GtkCellArea is only interested in button events, however some
- * customized derived areas can be implemented who are interested in handling
- * other events. Handling an event can trigger the #GtkCellArea::focus-changed
- * signal to fire as well as #GtkCellArea::add-editable in the case that
- * an editable cell was clicked and needs to start editing. You can call
+ * Passing events to the area is as simple as handling events on any
+ * normal widget and then passing them to the gtk_cell_area_event()
+ * API as they come in. Usually #GtkCellArea is only interested in
+ * button events, however some customized derived areas can be implemented
+ * who are interested in handling other events. Handling an event can
+ * trigger the #GtkCellArea::focus-changed signal to fire; as well as
+ * #GtkCellArea::add-editable in the case that an editable cell was
+ * clicked and needs to start editing. You can call
* gtk_cell_area_stop_editing() at any time to cancel any cell editing
* that is currently in progress.
*
- * The #GtkCellArea drives keyboard focus from cell to cell in a way similar
- * to #GtkWidget. For layouting widgets that support giving focus to cells it's
- * important to remember to pass %GTK_CELL_RENDERER_FOCUSED to the area functions
- * for the row that has focus and to tell the area to paint the focus at render
- * time.
- *
- * Layouting widgets that accept focus on cells should implement the #GtkWidgetClass.focus()
- * virtual method. The layouting widget is always responsible for knowing where
- * #GtkTreeModel rows are rendered inside the widget, so at #GtkWidgetClass.focus() time
- * the layouting widget should use the #GtkCellArea methods to navigate focus inside the
- * area and then observe the GtkDirectionType to pass the focus to adjacent rows and
- * areas.
- *
- * A basic example of how the #GtkWidgetClass.focus() virtual method should be implemented:
+ * The #GtkCellArea drives keyboard focus from cell to cell in a way
+ * similar to #GtkWidget. For layouting widgets that support giving
+ * focus to cells it's important to remember to pass %GTK_CELL_RENDERER_FOCUSED
+ * to the area functions for the row that has focus and to tell the
+ * area to paint the focus at render time.
+ *
+ * Layouting widgets that accept focus on cells should implement the
+ * #GtkWidgetClass.focus() virtual method. The layouting widget is always
+ * responsible for knowing where #GtkTreeModel rows are rendered inside
+ * the widget, so at #GtkWidgetClass.focus() time the layouting widget
+ * should use the #GtkCellArea methods to navigate focus inside the area
+ * and then observe the GtkDirectionType to pass the focus to adjacent
+ * rows and areas.
+ *
+ * A basic example of how the #GtkWidgetClass.focus() virtual method
+ * should be implemented:
* <example>
- * <title>Implementing keyboard focus navigation when displaying rows from top to bottom.</title>
+ * <title>Implementing keyboard focus navigation</title>
* <programlisting>
* static gboolean
* foo_focus (GtkWidget *widget,
@@ -309,31 +324,34 @@
* }
* </programlisting>
* </example>
+ * Note that the layouting widget is responsible for matching the
+ * GtkDirectionType values to the way it lays out its cells.
* </para>
* </refsect2>
* <refsect2 id="cell-properties">
* <title>Cell Properties</title>
* <para>
- * The #GtkCellArea introduces <emphasis>cell properties</emphasis> for #GtkCellRenderers in very
- * much the same way that #GtkContainer introduces <link linkend="child-properties">child properties</link>
- * for #GtkWidgets. This provides some general interfaces for defining the relationship cell areas
- * have with their cells. For instance in a #GtkCellAreaBox a cell might "expand" and recieve extra
- * space when the area is allocated more than it's full natural request, or a cell might be configured
- * to "align" with adjacent rows which were requested and rendered with the same #GtkCellAreaContext.
- *
- * Use gtk_cell_area_class_install_cell_property() to install cell properties
- * for a cell area class and gtk_cell_area_class_find_cell_property() or
- * gtk_cell_area_class_list_cell_properties() to get information about existing
- * cell properties.
+ * The #GtkCellArea introduces <emphasis>cell properties</emphasis>
+ * for #GtkCellRenderers in very much the same way that #GtkContainer
+ * introduces <link linkend="child-properties">child properties</link>
+ * for #GtkWidgets. This provides some general interfaces for defining
+ * the relationship cell areas have with their cells. For instance in a
+ * #GtkCellAreaBox a cell might "expand" and receive extra space when
+ * the area is allocated more than it's full natural request, or a cell
+ * might be configured to "align" with adjacent rows which were requested
+ * and rendered with the same #GtkCellAreaContext.
+ *
+ * Use gtk_cell_area_class_install_cell_property() to install cell
+ * properties for a cell area class and gtk_cell_area_class_find_cell_property()
+ * or gtk_cell_area_class_list_cell_properties() to get information about
+ * existing cell properties.
*
* To set the value of a cell property, use gtk_cell_area_cell_set_property(),
- * gtk_cell_area_cell_set() or gtk_cell_area_cell_set_valist().
- * To obtain the value of a cell property, use
- * gtk_cell_area_cell_get_property(), gtk_cell_area_cell_get() or
- * gtk_cell_area_cell_get_valist().
+ * gtk_cell_area_cell_set() or gtk_cell_area_cell_set_valist(). To obtain
+ * the value of a cell property, use gtk_cell_area_cell_get_property(),
+ * gtk_cell_area_cell_get() or gtk_cell_area_cell_get_valist().
* </para>
* </refsect2>
- *
*/
#include "config.h"
@@ -356,84 +374,84 @@
static void gtk_cell_area_dispose (GObject *object);
static void gtk_cell_area_finalize (GObject *object);
static void gtk_cell_area_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec);
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
static void gtk_cell_area_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec);
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
/* GtkCellAreaClass */
static gint gtk_cell_area_real_event (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- GdkEvent *event,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ GdkEvent *event,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags);
static void gtk_cell_area_real_render (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- cairo_t *cr,
- const GdkRectangle *background_area,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags,
- gboolean paint_focus);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ cairo_t *cr,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags,
+ gboolean paint_focus);
static void gtk_cell_area_real_apply_attributes (GtkCellArea *area,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gboolean is_expander,
- gboolean is_expanded);
+ GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ gboolean is_expander,
+ gboolean is_expanded);
static void gtk_cell_area_real_get_preferred_height_for_width (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint width,
+ gint *minimum_height,
+ gint *natural_height);
static void gtk_cell_area_real_get_preferred_width_for_height (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint height,
+ gint *minimum_width,
+ gint *natural_width);
static gboolean gtk_cell_area_real_is_activatable (GtkCellArea *area);
static gboolean gtk_cell_area_real_activate (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags,
- gboolean edit_only);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags,
+ gboolean edit_only);
/* GtkCellLayoutIface */
static void gtk_cell_area_cell_layout_init (GtkCellLayoutIface *iface);
static void gtk_cell_area_pack_default (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer,
- gboolean expand);
+ GtkCellRenderer *renderer,
+ gboolean expand);
static void gtk_cell_area_clear (GtkCellLayout *cell_layout);
static void gtk_cell_area_add_attribute (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer,
- const gchar *attribute,
- gint column);
+ GtkCellRenderer *renderer,
+ const gchar *attribute,
+ gint column);
static void gtk_cell_area_set_cell_data_func (GtkCellLayout *cell_layout,
- GtkCellRenderer *cell,
- GtkCellLayoutDataFunc func,
- gpointer func_data,
- GDestroyNotify destroy);
+ GtkCellRenderer *cell,
+ GtkCellLayoutDataFunc func,
+ gpointer func_data,
+ GDestroyNotify destroy);
static void gtk_cell_area_clear_attributes (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
static void gtk_cell_area_reorder (GtkCellLayout *cell_layout,
- GtkCellRenderer *cell,
- gint position);
+ GtkCellRenderer *cell,
+ gint position);
static GList *gtk_cell_area_get_cells (GtkCellLayout *cell_layout);
static GtkCellArea *gtk_cell_area_get_area (GtkCellLayout *cell_layout);
/* GtkBuildableIface */
static void gtk_cell_area_buildable_init (GtkBuildableIface *iface);
static void gtk_cell_area_buildable_custom_tag_end (GtkBuildable *buildable,
- GtkBuilder *builder,
- GObject *child,
- const gchar *tagname,
- gpointer *data);
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ gpointer *data);
/* Used in foreach loop to check if a child renderer is present */
typedef struct {
@@ -482,31 +500,31 @@ typedef struct {
} CellInfo;
static CellInfo *cell_info_new (GtkCellLayoutDataFunc func,
- gpointer data,
- GDestroyNotify destroy);
+ gpointer data,
+ GDestroyNotify destroy);
static void cell_info_free (CellInfo *info);
static CellAttribute *cell_attribute_new (GtkCellRenderer *renderer,
- const gchar *attribute,
- gint column);
+ const gchar *attribute,
+ gint column);
static void cell_attribute_free (CellAttribute *attribute);
static gint cell_attribute_find (CellAttribute *cell_attribute,
- const gchar *attribute);
+ const gchar *attribute);
/* Internal functions/signal emissions */
static void gtk_cell_area_add_editable (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GtkCellEditable *editable,
- const GdkRectangle *cell_area);
+ GtkCellRenderer *renderer,
+ GtkCellEditable *editable,
+ const GdkRectangle *cell_area);
static void gtk_cell_area_remove_editable (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GtkCellEditable *editable);
+ GtkCellRenderer *renderer,
+ GtkCellEditable *editable);
static void gtk_cell_area_set_edit_widget (GtkCellArea *area,
- GtkCellEditable *editable);
+ GtkCellEditable *editable);
static void gtk_cell_area_set_edited_cell (GtkCellArea *area,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
-/* Struct to pass data along while looping over
+/* Struct to pass data along while looping over
* cell renderers to apply attributes
*/
typedef struct {
@@ -519,13 +537,14 @@ typedef struct {
struct _GtkCellAreaPrivate
{
- /* The GtkCellArea bookkeeps any connected
+ /* The GtkCellArea bookkeeps any connected
* attributes in this hash table.
*/
GHashTable *cell_info;
/* Current path is saved as a side-effect
- * of gtk_cell_area_apply_attributes() */
+ * of gtk_cell_area_apply_attributes()
+ */
gchar *current_path;
/* Current cell being edited and editable widget used */
@@ -561,7 +580,8 @@ enum {
};
/* Keep the paramspec pool internal, no need to deliver notifications
- * on cells. at least no percieved need for now */
+ * on cells. at least no perceived need for now
+ */
static GParamSpecPool *cell_property_pool = NULL;
static guint cell_area_signals[LAST_SIGNAL] = { 0 };
@@ -569,10 +589,10 @@ static guint cell_area_signals[LAST_SIGNAL] = { 0 };
#define PARAM_SPEC_SET_PARAM_ID(pspec, id) ((pspec)->param_id = (id))
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GtkCellArea, gtk_cell_area, G_TYPE_INITIALLY_UNOWNED,
- G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
- gtk_cell_area_cell_layout_init)
- G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
- gtk_cell_area_buildable_init))
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
+ gtk_cell_area_cell_layout_init)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
+ gtk_cell_area_buildable_init))
static void
gtk_cell_area_init (GtkCellArea *area)
@@ -580,19 +600,19 @@ gtk_cell_area_init (GtkCellArea *area)
GtkCellAreaPrivate *priv;
area->priv = G_TYPE_INSTANCE_GET_PRIVATE (area,
- GTK_TYPE_CELL_AREA,
- GtkCellAreaPrivate);
+ GTK_TYPE_CELL_AREA,
+ GtkCellAreaPrivate);
priv = area->priv;
- priv->cell_info = g_hash_table_new_full (g_direct_hash,
- g_direct_equal,
- NULL,
- (GDestroyNotify)cell_info_free);
+ priv->cell_info = g_hash_table_new_full (g_direct_hash,
+ g_direct_equal,
+ NULL,
+ (GDestroyNotify)cell_info_free);
- priv->focus_siblings = g_hash_table_new_full (g_direct_hash,
- g_direct_equal,
- NULL,
- (GDestroyNotify)g_list_free);
+ priv->focus_siblings = g_hash_table_new_full (g_direct_hash,
+ g_direct_equal,
+ NULL,
+ (GDestroyNotify)g_list_free);
priv->focus_cell = NULL;
priv->edited_cell = NULL;
@@ -601,11 +621,11 @@ gtk_cell_area_init (GtkCellArea *area)
priv->remove_widget_id = 0;
}
-static void
+static void
gtk_cell_area_class_init (GtkCellAreaClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS (class);
-
+
/* GObjectClass */
object_class->dispose = gtk_cell_area_dispose;
object_class->finalize = gtk_cell_area_finalize;
@@ -648,16 +668,16 @@ gtk_cell_area_class_init (GtkCellAreaClass *class)
*/
cell_area_signals[SIGNAL_APPLY_ATTRIBUTES] =
g_signal_new (I_("apply-attributes"),
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_FIRST,
- G_STRUCT_OFFSET (GtkCellAreaClass, apply_attributes),
- NULL, NULL,
- _gtk_marshal_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN,
- G_TYPE_NONE, 4,
- GTK_TYPE_TREE_MODEL,
- GTK_TYPE_TREE_ITER,
- G_TYPE_BOOLEAN,
- G_TYPE_BOOLEAN);
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_FIRST,
+ G_STRUCT_OFFSET (GtkCellAreaClass, apply_attributes),
+ NULL, NULL,
+ _gtk_marshal_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN,
+ G_TYPE_NONE, 4,
+ GTK_TYPE_TREE_MODEL,
+ GTK_TYPE_TREE_ITER,
+ G_TYPE_BOOLEAN,
+ G_TYPE_BOOLEAN);
/**
* GtkCellArea::add-editable:
@@ -675,16 +695,16 @@ gtk_cell_area_class_init (GtkCellAreaClass *class)
*/
cell_area_signals[SIGNAL_ADD_EDITABLE] =
g_signal_new (I_("add-editable"),
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_FIRST,
- 0, /* No class closure here */
- NULL, NULL,
- _gtk_marshal_VOID__OBJECT_OBJECT_BOXED_STRING,
- G_TYPE_NONE, 4,
- GTK_TYPE_CELL_RENDERER,
- GTK_TYPE_CELL_EDITABLE,
- GDK_TYPE_RECTANGLE,
- G_TYPE_STRING);
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_FIRST,
+ 0, /* No class closure here */
+ NULL, NULL,
+ _gtk_marshal_VOID__OBJECT_OBJECT_BOXED_STRING,
+ G_TYPE_NONE, 4,
+ GTK_TYPE_CELL_RENDERER,
+ GTK_TYPE_CELL_EDITABLE,
+ GDK_TYPE_RECTANGLE,
+ G_TYPE_STRING);
/**
@@ -700,14 +720,14 @@ gtk_cell_area_class_init (GtkCellAreaClass *class)
*/
cell_area_signals[SIGNAL_REMOVE_EDITABLE] =
g_signal_new (I_("remove-editable"),
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_FIRST,
- 0, /* No class closure here */
- NULL, NULL,
- _gtk_marshal_VOID__OBJECT_OBJECT,
- G_TYPE_NONE, 2,
- GTK_TYPE_CELL_RENDERER,
- GTK_TYPE_CELL_EDITABLE);
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_FIRST,
+ 0, /* No class closure here */
+ NULL, NULL,
+ _gtk_marshal_VOID__OBJECT_OBJECT,
+ G_TYPE_NONE, 2,
+ GTK_TYPE_CELL_RENDERER,
+ GTK_TYPE_CELL_EDITABLE);
/**
* GtkCellArea::focus-changed:
@@ -728,14 +748,14 @@ gtk_cell_area_class_init (GtkCellAreaClass *class)
*/
cell_area_signals[SIGNAL_FOCUS_CHANGED] =
g_signal_new (I_("focus-changed"),
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_FIRST,
- 0, /* No class closure here */
- NULL, NULL,
- _gtk_marshal_VOID__OBJECT_STRING,
- G_TYPE_NONE, 2,
- GTK_TYPE_CELL_RENDERER,
- G_TYPE_STRING);
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_FIRST,
+ 0, /* No class closure here */
+ NULL, NULL,
+ _gtk_marshal_VOID__OBJECT_STRING,
+ G_TYPE_NONE, 2,
+ GTK_TYPE_CELL_RENDERER,
+ G_TYPE_STRING);
/* Properties */
/**
@@ -748,11 +768,11 @@ gtk_cell_area_class_init (GtkCellAreaClass *class)
g_object_class_install_property (object_class,
PROP_FOCUS_CELL,
g_param_spec_object
- ("focus-cell",
- P_("Focus Cell"),
- P_("The cell which currently has focus"),
- GTK_TYPE_CELL_RENDERER,
- GTK_PARAM_READWRITE));
+ ("focus-cell",
+ P_("Focus Cell"),
+ P_("The cell which currently has focus"),
+ GTK_TYPE_CELL_RENDERER,
+ GTK_PARAM_READWRITE));
/**
* GtkCellArea:edited-cell:
@@ -767,11 +787,11 @@ gtk_cell_area_class_init (GtkCellAreaClass *class)
g_object_class_install_property (object_class,
PROP_EDITED_CELL,
g_param_spec_object
- ("edited-cell",
- P_("Edited Cell"),
- P_("The cell which is currently being edited"),
- GTK_TYPE_CELL_RENDERER,
- G_PARAM_READABLE));
+ ("edited-cell",
+ P_("Edited Cell"),
+ P_("The cell which is currently being edited"),
+ GTK_TYPE_CELL_RENDERER,
+ G_PARAM_READABLE));
/**
* GtkCellArea:edit-widget:
@@ -786,11 +806,11 @@ gtk_cell_area_class_init (GtkCellAreaClass *class)
g_object_class_install_property (object_class,
PROP_EDIT_WIDGET,
g_param_spec_object
- ("edit-widget",
- P_("Edit Widget"),
- P_("The widget currently editing the edited cell"),
- GTK_TYPE_CELL_RENDERER,
- G_PARAM_READABLE));
+ ("edit-widget",
+ P_("Edit Widget"),
+ P_("The widget currently editing the edited cell"),
+ GTK_TYPE_CELL_RENDERER,
+ G_PARAM_READABLE));
/* Pool for Cell Properties */
if (!cell_property_pool)
@@ -804,8 +824,8 @@ gtk_cell_area_class_init (GtkCellAreaClass *class)
*************************************************************/
static CellInfo *
cell_info_new (GtkCellLayoutDataFunc func,
- gpointer data,
- GDestroyNotify destroy)
+ gpointer data,
+ GDestroyNotify destroy)
{
CellInfo *info = g_slice_new0 (CellInfo);
@@ -830,14 +850,14 @@ cell_info_free (CellInfo *info)
static CellAttribute *
cell_attribute_new (GtkCellRenderer *renderer,
- const gchar *attribute,
- gint column)
+ const gchar *attribute,
+ gint column)
{
GParamSpec *pspec;
/* Check if the attribute really exists and point to
* the property string installed on the cell renderer
- * class (dont dup the string)
+ * class (dont dup the string)
*/
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (renderer), attribute);
@@ -863,7 +883,7 @@ cell_attribute_free (CellAttribute *attribute)
/* GCompareFunc for g_slist_find_custom() */
static gint
cell_attribute_find (CellAttribute *cell_attribute,
- const gchar *attribute)
+ const gchar *attribute)
{
return g_strcmp0 (cell_attribute->attribute, attribute);
}
@@ -878,7 +898,7 @@ gtk_cell_area_finalize (GObject *object)
GtkCellAreaPrivate *priv = area->priv;
/* All cell renderers should already be removed at this point,
- * just kill our (empty) hash tables here.
+ * just kill our (empty) hash tables here.
*/
g_hash_table_destroy (priv->cell_info);
g_hash_table_destroy (priv->focus_siblings);
@@ -893,7 +913,7 @@ static void
gtk_cell_area_dispose (GObject *object)
{
/* This removes every cell renderer that may be added to the GtkCellArea,
- * subclasses should be breaking references to the GtkCellRenderers
+ * subclasses should be breaking references to the GtkCellRenderers
* at this point.
*/
gtk_cell_layout_clear (GTK_CELL_LAYOUT (object));
@@ -908,9 +928,9 @@ gtk_cell_area_dispose (GObject *object)
static void
gtk_cell_area_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec)
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
GtkCellArea *area = GTK_CELL_AREA (object);
@@ -927,9 +947,9 @@ gtk_cell_area_set_property (GObject *object,
static void
gtk_cell_area_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
GtkCellArea *area = GTK_CELL_AREA (object);
GtkCellAreaPrivate *priv = area->priv;
@@ -956,11 +976,11 @@ gtk_cell_area_get_property (GObject *object,
*************************************************************/
static gint
gtk_cell_area_real_event (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- GdkEvent *event,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ GdkEvent *event,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags)
{
GtkCellAreaPrivate *priv = area->priv;
gboolean retval = FALSE;
@@ -971,65 +991,65 @@ gtk_cell_area_real_event (GtkCellArea *area,
/* Cancel any edits in progress */
if (priv->edited_cell && (key_event->keyval == GDK_KEY_Escape))
- {
- gtk_cell_area_stop_editing (area, TRUE);
- retval = TRUE;
- }
+ {
+ gtk_cell_area_stop_editing (area, TRUE);
+ retval = TRUE;
+ }
}
else if (event->type == GDK_BUTTON_PRESS)
{
GdkEventButton *button_event = (GdkEventButton *)event;
if (button_event->button == 1)
- {
- GtkCellRenderer *renderer = NULL;
- GtkCellRenderer *focus_renderer;
- GdkRectangle alloc_area;
- gint event_x, event_y;
-
- /* We may need some semantics to tell us the offset of the event
- * window we are handling events for (i.e. GtkTreeView has a bin_window) */
- event_x = button_event->x;
- event_y = button_event->y;
-
- /* Dont try to search for an event coordinate that is not in the area, that will
- * trigger a runtime warning.
- */
- if (event_x >= cell_area->x && event_x <= cell_area->x + cell_area->width &&
- event_y >= cell_area->y && event_y <= cell_area->y + cell_area->height)
- renderer =
- gtk_cell_area_get_cell_at_position (area, context, widget,
- cell_area, event_x, event_y,
- &alloc_area);
-
- if (renderer)
- {
- focus_renderer = gtk_cell_area_get_focus_from_sibling (area, renderer);
- if (!focus_renderer)
- focus_renderer = renderer;
-
- /* If we're already editing, cancel it and set focus */
- if (gtk_cell_area_get_edited_cell (area))
- {
- /* XXX Was it really canceled in this case ? */
- gtk_cell_area_stop_editing (area, TRUE);
- gtk_cell_area_set_focus_cell (area, focus_renderer);
- retval = TRUE;
- }
- else
- {
- /* If we are activating via a focus sibling,
- * we need to fetch the right cell area for the real event renderer */
- if (focus_renderer != renderer)
- gtk_cell_area_get_cell_allocation (area, context, widget, focus_renderer,
- cell_area, &alloc_area);
-
- gtk_cell_area_set_focus_cell (area, focus_renderer);
- retval = gtk_cell_area_activate_cell (area, widget, focus_renderer,
- event, &alloc_area, flags);
- }
- }
- }
+ {
+ GtkCellRenderer *renderer = NULL;
+ GtkCellRenderer *focus_renderer;
+ GdkRectangle alloc_area;
+ gint event_x, event_y;
+
+ /* We may need some semantics to tell us the offset of the event
+ * window we are handling events for (i.e. GtkTreeView has a bin_window) */
+ event_x = button_event->x;
+ event_y = button_event->y;
+
+ /* Dont try to search for an event coordinate that is not in the area, that will
+ * trigger a runtime warning.
+ */
+ if (event_x >= cell_area->x && event_x <= cell_area->x + cell_area->width &&
+ event_y >= cell_area->y && event_y <= cell_area->y + cell_area->height)
+ renderer =
+ gtk_cell_area_get_cell_at_position (area, context, widget,
+ cell_area, event_x, event_y,
+ &alloc_area);
+
+ if (renderer)
+ {
+ focus_renderer = gtk_cell_area_get_focus_from_sibling (area, renderer);
+ if (!focus_renderer)
+ focus_renderer = renderer;
+
+ /* If we're already editing, cancel it and set focus */
+ if (gtk_cell_area_get_edited_cell (area))
+ {
+ /* XXX Was it really canceled in this case ? */
+ gtk_cell_area_stop_editing (area, TRUE);
+ gtk_cell_area_set_focus_cell (area, focus_renderer);
+ retval = TRUE;
+ }
+ else
+ {
+ /* If we are activating via a focus sibling,
+ * we need to fetch the right cell area for the real event renderer */
+ if (focus_renderer != renderer)
+ gtk_cell_area_get_cell_allocation (area, context, widget, focus_renderer,
+ cell_area, &alloc_area);
+
+ gtk_cell_area_set_focus_cell (area, focus_renderer);
+ retval = gtk_cell_area_activate_cell (area, widget, focus_renderer,
+ event, &alloc_area, flags);
+ }
+ }
+ }
}
return retval;
@@ -1037,9 +1057,9 @@ gtk_cell_area_real_event (GtkCellArea *area,
static gboolean
render_cell (GtkCellRenderer *renderer,
- const GdkRectangle *cell_area,
- const GdkRectangle *cell_background,
- CellRenderData *data)
+ const GdkRectangle *cell_area,
+ const GdkRectangle *cell_background,
+ CellRenderData *data)
{
GtkCellRenderer *focus_cell;
GtkCellRendererState flags;
@@ -1051,10 +1071,10 @@ render_cell (GtkCellRenderer *renderer,
gtk_cell_area_inner_cell_area (data->area, data->widget, cell_area, &inner_area);
if ((flags & GTK_CELL_RENDERER_FOCUSED) &&
- (data->focus_all ||
- (focus_cell &&
- (renderer == focus_cell ||
- gtk_cell_area_is_focus_sibling (data->area, focus_cell, renderer)))))
+ (data->focus_all ||
+ (focus_cell &&
+ (renderer == focus_cell ||
+ gtk_cell_area_is_focus_sibling (data->area, focus_cell, renderer)))))
{
gint focus_line_width;
GdkRectangle cell_focus;
@@ -1072,79 +1092,79 @@ render_cell (GtkCellRenderer *renderer,
cell_focus.height += 2 * focus_line_width;
if (data->first_focus)
- {
- data->first_focus = FALSE;
- data->focus_rect = cell_focus;
- }
+ {
+ data->first_focus = FALSE;
+ data->focus_rect = cell_focus;
+ }
else
- {
- gdk_rectangle_union (&data->focus_rect, &cell_focus, &data->focus_rect);
- }
+ {
+ gdk_rectangle_union (&data->focus_rect, &cell_focus, &data->focus_rect);
+ }
}
else
flags &= ~GTK_CELL_RENDERER_FOCUSED;
gtk_cell_renderer_render (renderer, data->cr, data->widget,
- cell_background, &inner_area, flags);
+ cell_background, &inner_area, flags);
return FALSE;
}
static void
gtk_cell_area_real_render (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- cairo_t *cr,
- const GdkRectangle *background_area,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags,
- gboolean paint_focus)
-{
- CellRenderData render_data =
- {
- area,
- widget,
- cr,
- { 0, },
- flags,
- paint_focus,
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ cairo_t *cr,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags,
+ gboolean paint_focus)
+{
+ CellRenderData render_data =
+ {
+ area,
+ widget,
+ cr,
+ { 0, },
+ flags,
+ paint_focus,
FALSE, TRUE
};
/* Make sure we dont paint a focus rectangle while there
- * is an editable widget in play
+ * is an editable widget in play
*/
if (gtk_cell_area_get_edited_cell (area))
render_data.paint_focus = FALSE;
/* If no cell can activate but the caller wants focus painted,
* then we paint focus around all cells */
- if ((flags & GTK_CELL_RENDERER_FOCUSED) != 0 && paint_focus &&
+ if ((flags & GTK_CELL_RENDERER_FOCUSED) != 0 && paint_focus &&
!gtk_cell_area_is_activatable (area))
render_data.focus_all = TRUE;
- gtk_cell_area_foreach_alloc (area, context, widget, cell_area, background_area,
- (GtkCellAllocCallback)render_cell, &render_data);
+ gtk_cell_area_foreach_alloc (area, context, widget, cell_area, background_area,
+ (GtkCellAllocCallback)render_cell, &render_data);
- if (render_data.paint_focus &&
- render_data.focus_rect.width != 0 &&
+ if (render_data.paint_focus &&
+ render_data.focus_rect.width != 0 &&
render_data.focus_rect.height != 0)
{
- GtkStateType renderer_state =
- flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
- (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
- (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL));
+ GtkStateType renderer_state =
+ flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
+ (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
+ (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL));
cairo_save (cr);
gdk_cairo_rectangle (cr, background_area);
cairo_clip (cr);
- gtk_paint_focus (gtk_widget_get_style (widget), cr,
- renderer_state, widget,
- gtk_cell_area_get_style_detail (area),
- render_data.focus_rect.x, render_data.focus_rect.y,
- render_data.focus_rect.width, render_data.focus_rect.height);
+ gtk_paint_focus (gtk_widget_get_style (widget), cr,
+ renderer_state, widget,
+ gtk_cell_area_get_style_detail (area),
+ render_data.focus_rect.x, render_data.focus_rect.y,
+ render_data.focus_rect.width, render_data.focus_rect.height);
cairo_restore (cr);
}
@@ -1152,8 +1172,8 @@ gtk_cell_area_real_render (GtkCellArea *area,
static void
apply_cell_attributes (GtkCellRenderer *renderer,
- CellInfo *info,
- AttributeData *data)
+ CellInfo *info,
+ AttributeData *data)
{
CellAttribute *attribute;
GSList *list;
@@ -1163,14 +1183,14 @@ apply_cell_attributes (GtkCellRenderer *renderer,
g_object_freeze_notify (G_OBJECT (renderer));
- /* Whether a row expands or is presently expanded can only be
+ /* Whether a row expands or is presently expanded can only be
* provided by the view (as these states can vary across views
* accessing the same model).
*/
g_object_get (renderer, "is-expander", &is_expander, NULL);
if (is_expander != data->is_expander)
g_object_set (renderer, "is-expander", data->is_expander, NULL);
-
+
g_object_get (renderer, "is-expanded", &is_expanded, NULL);
if (is_expanded != data->is_expanded)
g_object_set (renderer, "is-expanded", data->is_expanded, NULL);
@@ -1189,17 +1209,17 @@ apply_cell_attributes (GtkCellRenderer *renderer,
*/
if (info->func)
info->func (GTK_CELL_LAYOUT (data->area), renderer,
- data->model, data->iter, info->data);
+ data->model, data->iter, info->data);
g_object_thaw_notify (G_OBJECT (renderer));
}
static void
gtk_cell_area_real_apply_attributes (GtkCellArea *area,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gboolean is_expander,
- gboolean is_expanded)
+ GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ gboolean is_expander,
+ gboolean is_expanded)
{
GtkCellAreaPrivate *priv;
@@ -1228,11 +1248,11 @@ gtk_cell_area_real_apply_attributes (GtkCellArea *area,
static void
gtk_cell_area_real_get_preferred_height_for_width (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint width,
+ gint *minimum_height,
+ gint *natural_height)
{
/* If the area doesnt do height-for-width, fallback on base preferred height */
GTK_CELL_AREA_GET_CLASS (area)->get_preferred_width (area, context, widget, minimum_height, natural_height);
@@ -1240,11 +1260,11 @@ gtk_cell_area_real_get_preferred_height_for_width (GtkCellArea *area,
static void
gtk_cell_area_real_get_preferred_width_for_height (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint height,
+ gint *minimum_width,
+ gint *natural_width)
{
/* If the area doesnt do width-for-height, fallback on base preferred width */
GTK_CELL_AREA_GET_CLASS (area)->get_preferred_width (area, context, widget, minimum_width, natural_width);
@@ -1252,7 +1272,7 @@ gtk_cell_area_real_get_preferred_width_for_height (GtkCellArea *area,
static gboolean
get_is_activatable (GtkCellRenderer *renderer,
- gboolean *activatable)
+ gboolean *activatable)
{
if (gtk_cell_renderer_is_activatable (renderer))
@@ -1279,11 +1299,11 @@ gtk_cell_area_real_is_activatable (GtkCellArea *area)
static gboolean
gtk_cell_area_real_activate (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags,
- gboolean edit_only)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags,
+ gboolean edit_only)
{
GtkCellAreaPrivate *priv = area->priv;
GdkRectangle renderer_area;
@@ -1295,9 +1315,9 @@ gtk_cell_area_real_activate (GtkCellArea *area,
g_object_get (priv->focus_cell, "mode", &mode, NULL);
if (gtk_cell_renderer_get_visible (priv->focus_cell) &&
- (edit_only ? mode == GTK_CELL_RENDERER_MODE_EDITABLE :
- mode != GTK_CELL_RENDERER_MODE_INERT))
- activate_cell = priv->focus_cell;
+ (edit_only ? mode == GTK_CELL_RENDERER_MODE_EDITABLE :
+ mode != GTK_CELL_RENDERER_MODE_INERT))
+ activate_cell = priv->focus_cell;
}
else
{
@@ -1308,16 +1328,16 @@ gtk_cell_area_real_activate (GtkCellArea *area,
*/
cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area));
for (l = cells; l && !activate_cell; l = l->next)
- {
- GtkCellRenderer *renderer = l->data;
+ {
+ GtkCellRenderer *renderer = l->data;
- g_object_get (renderer, "mode", &mode, NULL);
+ g_object_get (renderer, "mode", &mode, NULL);
- if (gtk_cell_renderer_get_visible (renderer) &&
- (edit_only ? mode == GTK_CELL_RENDERER_MODE_EDITABLE :
- mode != GTK_CELL_RENDERER_MODE_INERT))
- activate_cell = renderer;
- }
+ if (gtk_cell_renderer_get_visible (renderer) &&
+ (edit_only ? mode == GTK_CELL_RENDERER_MODE_EDITABLE :
+ mode != GTK_CELL_RENDERER_MODE_INERT))
+ activate_cell = renderer;
+ }
g_list_free (cells);
}
@@ -1326,16 +1346,16 @@ gtk_cell_area_real_activate (GtkCellArea *area,
/* Get the allocation of the focused cell.
*/
gtk_cell_area_get_cell_allocation (area, context, widget, activate_cell,
- cell_area, &renderer_area);
-
+ cell_area, &renderer_area);
+
/* Activate or Edit the cell
*
* Currently just not sending an event, renderers afaics dont use
* the event argument anyway, worst case is we can synthesize one.
*/
if (gtk_cell_area_activate_cell (area, widget, activate_cell, NULL,
- &renderer_area, flags))
- return TRUE;
+ &renderer_area, flags))
+ return TRUE;
}
return FALSE;
@@ -1360,8 +1380,8 @@ gtk_cell_area_cell_layout_init (GtkCellLayoutIface *iface)
static void
gtk_cell_area_pack_default (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer,
- gboolean expand)
+ GtkCellRenderer *renderer,
+ gboolean expand)
{
gtk_cell_area_add (GTK_CELL_AREA (cell_layout), renderer);
}
@@ -1384,20 +1404,20 @@ gtk_cell_area_clear (GtkCellLayout *cell_layout)
static void
gtk_cell_area_add_attribute (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer,
- const gchar *attribute,
- gint column)
+ GtkCellRenderer *renderer,
+ const gchar *attribute,
+ gint column)
{
gtk_cell_area_attribute_connect (GTK_CELL_AREA (cell_layout),
- renderer, attribute, column);
+ renderer, attribute, column);
}
static void
gtk_cell_area_set_cell_data_func (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer,
- GtkCellLayoutDataFunc func,
- gpointer func_data,
- GDestroyNotify destroy)
+ GtkCellRenderer *renderer,
+ GtkCellLayoutDataFunc func,
+ gpointer func_data,
+ GDestroyNotify destroy)
{
GtkCellArea *area = GTK_CELL_AREA (cell_layout);
GtkCellAreaPrivate *priv = area->priv;
@@ -1408,20 +1428,20 @@ gtk_cell_area_set_cell_data_func (GtkCellLayout *cell_layout,
if (info)
{
if (info->destroy && info->data)
- info->destroy (info->data);
+ info->destroy (info->data);
if (func)
- {
- info->func = func;
- info->data = func_data;
- info->destroy = destroy;
- }
+ {
+ info->func = func;
+ info->data = func_data;
+ info->destroy = destroy;
+ }
else
- {
- info->func = NULL;
- info->data = NULL;
- info->destroy = NULL;
- }
+ {
+ info->func = NULL;
+ info->data = NULL;
+ info->destroy = NULL;
+ }
}
else
{
@@ -1433,7 +1453,7 @@ gtk_cell_area_set_cell_data_func (GtkCellLayout *cell_layout,
static void
gtk_cell_area_clear_attributes (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer)
+ GtkCellRenderer *renderer)
{
GtkCellArea *area = GTK_CELL_AREA (cell_layout);
GtkCellAreaPrivate *priv = area->priv;
@@ -1450,18 +1470,18 @@ gtk_cell_area_clear_attributes (GtkCellLayout *cell_layout,
}
}
-static void
+static void
gtk_cell_area_reorder (GtkCellLayout *cell_layout,
- GtkCellRenderer *cell,
- gint position)
+ GtkCellRenderer *cell,
+ gint position)
{
- g_warning ("GtkCellLayout::reorder not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (cell_layout)));
+ g_warning ("GtkCellLayout::reorder not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (cell_layout)));
}
static gboolean
accum_cells (GtkCellRenderer *renderer,
- GList **accum)
+ GList **accum)
{
*accum = g_list_prepend (*accum, renderer);
@@ -1473,9 +1493,9 @@ gtk_cell_area_get_cells (GtkCellLayout *cell_layout)
{
GList *cells = NULL;
- gtk_cell_area_foreach (GTK_CELL_AREA (cell_layout),
- (GtkCellCallback)accum_cells,
- &cells);
+ gtk_cell_area_foreach (GTK_CELL_AREA (cell_layout),
+ (GtkCellCallback)accum_cells,
+ &cells);
return g_list_reverse (cells);
}
@@ -1499,10 +1519,10 @@ gtk_cell_area_buildable_init (GtkBuildableIface *iface)
static void
gtk_cell_area_buildable_custom_tag_end (GtkBuildable *buildable,
- GtkBuilder *builder,
- GObject *child,
- const gchar *tagname,
- gpointer *data)
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ gpointer *data)
{
/* Just ignore the boolean return from here */
_gtk_cell_layout_buildable_custom_tag_end (buildable, builder, child, tagname, data);
@@ -1523,7 +1543,7 @@ gtk_cell_area_buildable_custom_tag_end (GtkBuildable *buildable,
*/
void
gtk_cell_area_add (GtkCellArea *area,
- GtkCellRenderer *renderer)
+ GtkCellRenderer *renderer)
{
GtkCellAreaClass *class;
@@ -1535,8 +1555,8 @@ gtk_cell_area_add (GtkCellArea *area,
if (class->add)
class->add (area, renderer);
else
- g_warning ("GtkCellAreaClass::add not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
+ g_warning ("GtkCellAreaClass::add not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
/**
@@ -1550,7 +1570,7 @@ gtk_cell_area_add (GtkCellArea *area,
*/
void
gtk_cell_area_remove (GtkCellArea *area,
- GtkCellRenderer *renderer)
+ GtkCellRenderer *renderer)
{
GtkCellAreaClass *class;
GtkCellAreaPrivate *priv;
@@ -1568,7 +1588,7 @@ gtk_cell_area_remove (GtkCellArea *area,
/* Remove focus siblings of this renderer */
g_hash_table_remove (priv->focus_siblings, renderer);
- /* Remove this renderer from any focus renderer's sibling list */
+ /* Remove this renderer from any focus renderer's sibling list */
renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area));
for (l = renderers; l; l = l->next)
@@ -1576,10 +1596,10 @@ gtk_cell_area_remove (GtkCellArea *area,
GtkCellRenderer *focus_renderer = l->data;
if (gtk_cell_area_is_focus_sibling (area, focus_renderer, renderer))
- {
- gtk_cell_area_remove_focus_sibling (area, focus_renderer, renderer);
- break;
- }
+ {
+ gtk_cell_area_remove_focus_sibling (area, focus_renderer, renderer);
+ break;
+ }
}
g_list_free (renderers);
@@ -1587,13 +1607,13 @@ gtk_cell_area_remove (GtkCellArea *area,
if (class->remove)
class->remove (area, renderer);
else
- g_warning ("GtkCellAreaClass::remove not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
+ g_warning ("GtkCellAreaClass::remove not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
static gboolean
get_has_renderer (GtkCellRenderer *renderer,
- HasRendererCheck *check)
+ HasRendererCheck *check)
{
if (renderer == check->renderer)
check->has_renderer = TRUE;
@@ -1614,7 +1634,7 @@ get_has_renderer (GtkCellRenderer *renderer,
*/
gboolean
gtk_cell_area_has_renderer (GtkCellArea *area,
- GtkCellRenderer *renderer)
+ GtkCellRenderer *renderer)
{
HasRendererCheck check = { renderer, FALSE };
@@ -1638,8 +1658,8 @@ gtk_cell_area_has_renderer (GtkCellArea *area,
*/
void
gtk_cell_area_foreach (GtkCellArea *area,
- GtkCellCallback callback,
- gpointer callback_data)
+ GtkCellCallback callback,
+ gpointer callback_data)
{
GtkCellAreaClass *class;
@@ -1651,8 +1671,8 @@ gtk_cell_area_foreach (GtkCellArea *area,
if (class->foreach)
class->foreach (area, callback, callback_data);
else
- g_warning ("GtkCellAreaClass::foreach not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
+ g_warning ("GtkCellAreaClass::foreach not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
/**
@@ -1672,12 +1692,12 @@ gtk_cell_area_foreach (GtkCellArea *area,
*/
void
gtk_cell_area_foreach_alloc (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- const GdkRectangle *background_area,
- GtkCellAllocCallback callback,
- gpointer callback_data)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ const GdkRectangle *background_area,
+ GtkCellAllocCallback callback,
+ gpointer callback_data)
{
GtkCellAreaClass *class;
@@ -1692,8 +1712,8 @@ gtk_cell_area_foreach_alloc (GtkCellArea *area,
if (class->foreach_alloc)
class->foreach_alloc (area, context, widget, cell_area, background_area, callback, callback_data);
else
- g_warning ("GtkCellAreaClass::foreach_alloc not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
+ g_warning ("GtkCellAreaClass::foreach_alloc not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
/**
@@ -1713,11 +1733,11 @@ gtk_cell_area_foreach_alloc (GtkCellArea *area,
*/
gint
gtk_cell_area_event (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- GdkEvent *event,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ GdkEvent *event,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags)
{
GtkCellAreaClass *class;
@@ -1732,8 +1752,8 @@ gtk_cell_area_event (GtkCellArea *area,
if (class->event)
return class->event (area, context, widget, event, cell_area, flags);
- g_warning ("GtkCellAreaClass::event not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
+ g_warning ("GtkCellAreaClass::event not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
return 0;
}
@@ -1755,13 +1775,13 @@ gtk_cell_area_event (GtkCellArea *area,
*/
void
gtk_cell_area_render (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- cairo_t *cr,
- const GdkRectangle *background_area,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags,
- gboolean paint_focus)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ cairo_t *cr,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags,
+ gboolean paint_focus)
{
GtkCellAreaClass *class;
@@ -1777,8 +1797,8 @@ gtk_cell_area_render (GtkCellArea *area,
if (class->render)
class->render (area, context, widget, cr, background_area, cell_area, flags, paint_focus);
else
- g_warning ("GtkCellAreaClass::render not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
+ g_warning ("GtkCellAreaClass::render not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
/**
@@ -1793,7 +1813,7 @@ gtk_cell_area_render (GtkCellArea *area,
*/
void
gtk_cell_area_set_style_detail (GtkCellArea *area,
- const gchar *detail)
+ const gchar *detail)
{
GtkCellAreaPrivate *priv;
@@ -1833,9 +1853,9 @@ gtk_cell_area_get_style_detail (GtkCellArea *area)
static gboolean
get_cell_allocation (GtkCellRenderer *renderer,
- const GdkRectangle *cell_area,
- const GdkRectangle *cell_background,
- RendererAllocationData *data)
+ const GdkRectangle *cell_area,
+ const GdkRectangle *cell_background,
+ RendererAllocationData *data)
{
if (data->renderer == renderer)
data->allocation = *cell_area;
@@ -1860,11 +1880,11 @@ get_cell_allocation (GtkCellRenderer *renderer,
*/
void
gtk_cell_area_get_cell_allocation (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- GtkCellRenderer *renderer,
- const GdkRectangle *cell_area,
- GdkRectangle *allocation)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ GtkCellRenderer *renderer,
+ const GdkRectangle *cell_area,
+ GdkRectangle *allocation)
{
RendererAllocationData data = { renderer, { 0, } };
@@ -1875,17 +1895,17 @@ gtk_cell_area_get_cell_allocation (GtkCellArea *area,
g_return_if_fail (cell_area != NULL);
g_return_if_fail (allocation != NULL);
- gtk_cell_area_foreach_alloc (area, context, widget, cell_area, cell_area,
- (GtkCellAllocCallback)get_cell_allocation, &data);
+ gtk_cell_area_foreach_alloc (area, context, widget, cell_area, cell_area,
+ (GtkCellAllocCallback)get_cell_allocation, &data);
*allocation = data.allocation;
}
static gboolean
get_cell_by_position (GtkCellRenderer *renderer,
- const GdkRectangle *cell_area,
- const GdkRectangle *cell_background,
- CellByPositionData *data)
+ const GdkRectangle *cell_area,
+ const GdkRectangle *cell_background,
+ CellByPositionData *data)
{
if (data->x >= cell_area->x && data->x < cell_area->x + cell_area->width &&
data->y >= cell_area->y && data->y < cell_area->y + cell_area->height)
@@ -1906,7 +1926,7 @@ get_cell_by_position (GtkCellRenderer *renderer,
* for this row
* @x: the x position
* @y: the y position
- * @alloc_area: (out) (allow-none): where to store the inner allocated area of the
+ * @alloc_area: (out) (allow-none): where to store the inner allocated area of the
* returned cell renderer, or %NULL.
*
* Gets the #GtkCellRenderer at @x and @y coordinates inside @area and optionally
@@ -1918,12 +1938,12 @@ get_cell_by_position (GtkCellRenderer *renderer,
*/
GtkCellRenderer *
gtk_cell_area_get_cell_at_position (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- gint x,
- gint y,
- GdkRectangle *alloc_area)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ gint x,
+ gint y,
+ GdkRectangle *alloc_area)
{
CellByPositionData data = { x, y, NULL, { 0, } };
@@ -1934,8 +1954,8 @@ gtk_cell_area_get_cell_at_position (GtkCellArea *area,
g_return_val_if_fail (x >= cell_area->x && x <= cell_area->x + cell_area->width, NULL);
g_return_val_if_fail (y >= cell_area->y && y <= cell_area->y + cell_area->height, NULL);
- gtk_cell_area_foreach_alloc (area, context, widget, cell_area, cell_area,
- (GtkCellAllocCallback)get_cell_by_position, &data);
+ gtk_cell_area_foreach_alloc (area, context, widget, cell_area, cell_area,
+ (GtkCellAllocCallback)get_cell_by_position, &data);
if (alloc_area)
*alloc_area = data.cell_area;
@@ -1973,9 +1993,9 @@ gtk_cell_area_create_context (GtkCellArea *area)
if (class->create_context)
return class->create_context (area);
- g_warning ("GtkCellAreaClass::create_context not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
-
+ g_warning ("GtkCellAreaClass::create_context not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
+
return NULL;
}
@@ -2002,7 +2022,7 @@ gtk_cell_area_create_context (GtkCellArea *area)
*/
GtkCellAreaContext *
gtk_cell_area_copy_context (GtkCellArea *area,
- GtkCellAreaContext *context)
+ GtkCellAreaContext *context)
{
GtkCellAreaClass *class;
@@ -2014,9 +2034,9 @@ gtk_cell_area_copy_context (GtkCellArea *area,
if (class->copy_context)
return class->copy_context (area, context);
- g_warning ("GtkCellAreaClass::copy_context not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
-
+ g_warning ("GtkCellAreaClass::copy_context not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
+
return NULL;
}
@@ -2031,22 +2051,22 @@ gtk_cell_area_copy_context (GtkCellArea *area,
*
* Since: 3.0
*/
-GtkSizeRequestMode
+GtkSizeRequestMode
gtk_cell_area_get_request_mode (GtkCellArea *area)
{
GtkCellAreaClass *class;
- g_return_val_if_fail (GTK_IS_CELL_AREA (area),
- GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH);
+ g_return_val_if_fail (GTK_IS_CELL_AREA (area),
+ GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH);
class = GTK_CELL_AREA_GET_CLASS (area);
if (class->get_request_mode)
return class->get_request_mode (area);
- g_warning ("GtkCellAreaClass::get_request_mode not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
-
+ g_warning ("GtkCellAreaClass::get_request_mode not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
+
return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
}
@@ -2070,10 +2090,10 @@ gtk_cell_area_get_request_mode (GtkCellArea *area)
*/
void
gtk_cell_area_get_preferred_width (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint *minimum_width,
- gint *natural_width)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint *minimum_width,
+ gint *natural_width)
{
GtkCellAreaClass *class;
@@ -2085,8 +2105,8 @@ gtk_cell_area_get_preferred_width (GtkCellArea *area,
if (class->get_preferred_width)
class->get_preferred_width (area, context, widget, minimum_width, natural_width);
else
- g_warning ("GtkCellAreaClass::get_preferred_width not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
+ g_warning ("GtkCellAreaClass::get_preferred_width not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
/**
@@ -2117,11 +2137,11 @@ gtk_cell_area_get_preferred_width (GtkCellArea *area,
*/
void
gtk_cell_area_get_preferred_height_for_width (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint width,
+ gint *minimum_height,
+ gint *natural_height)
{
GtkCellAreaClass *class;
@@ -2153,10 +2173,10 @@ gtk_cell_area_get_preferred_height_for_width (GtkCellArea *area,
*/
void
gtk_cell_area_get_preferred_height (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint *minimum_height,
- gint *natural_height)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint *minimum_height,
+ gint *natural_height)
{
GtkCellAreaClass *class;
@@ -2168,8 +2188,8 @@ gtk_cell_area_get_preferred_height (GtkCellArea *area,
if (class->get_preferred_height)
class->get_preferred_height (area, context, widget, minimum_height, natural_height);
else
- g_warning ("GtkCellAreaClass::get_preferred_height not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
+ g_warning ("GtkCellAreaClass::get_preferred_height not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
/**
@@ -2200,11 +2220,11 @@ gtk_cell_area_get_preferred_height (GtkCellArea *area,
*/
void
gtk_cell_area_get_preferred_width_for_height (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint height,
+ gint *minimum_width,
+ gint *natural_width)
{
GtkCellAreaClass *class;
@@ -2233,10 +2253,10 @@ gtk_cell_area_get_preferred_width_for_height (GtkCellArea *area,
*/
void
gtk_cell_area_attribute_connect (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *attribute,
- gint column)
-{
+ GtkCellRenderer *renderer,
+ const gchar *attribute,
+ gint column)
+{
GtkCellAreaPrivate *priv;
CellInfo *info;
CellAttribute *cell_attribute;
@@ -2261,17 +2281,17 @@ gtk_cell_area_attribute_connect (GtkCellArea *area,
/* Check we are not adding the same attribute twice */
if ((node = g_slist_find_custom (info->attributes, attribute,
- (GCompareFunc)cell_attribute_find)) != NULL)
- {
- cell_attribute = node->data;
-
- g_warning ("Cannot connect attribute `%s' for cell renderer class `%s' "
- "since `%s' is already attributed to column %d",
- attribute,
- g_type_name (G_TYPE_FROM_INSTANCE (area)),
- attribute, cell_attribute->column);
- return;
- }
+ (GCompareFunc)cell_attribute_find)) != NULL)
+ {
+ cell_attribute = node->data;
+
+ g_warning ("Cannot connect attribute `%s' for cell renderer class `%s' "
+ "since `%s' is already attributed to column %d",
+ attribute,
+ g_type_name (G_TYPE_FROM_INSTANCE (area)),
+ attribute, cell_attribute->column);
+ return;
+ }
}
cell_attribute = cell_attribute_new (renderer, attribute, column);
@@ -2279,9 +2299,9 @@ gtk_cell_area_attribute_connect (GtkCellArea *area,
if (!cell_attribute)
{
g_warning ("Cannot connect attribute `%s' for cell renderer class `%s' "
- "since attribute does not exist",
- attribute,
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
+ "since attribute does not exist",
+ attribute,
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
return;
}
@@ -2300,10 +2320,10 @@ gtk_cell_area_attribute_connect (GtkCellArea *area,
*
* Since: 3.0
*/
-void
+void
gtk_cell_area_attribute_disconnect (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *attribute)
+ GtkCellRenderer *renderer,
+ const gchar *attribute)
{
GtkCellAreaPrivate *priv;
CellInfo *info;
@@ -2321,15 +2341,15 @@ gtk_cell_area_attribute_disconnect (GtkCellArea *area,
if (info)
{
node = g_slist_find_custom (info->attributes, attribute,
- (GCompareFunc)cell_attribute_find);
+ (GCompareFunc)cell_attribute_find);
if (node)
- {
- cell_attribute = node->data;
+ {
+ cell_attribute = node->data;
- cell_attribute_free (cell_attribute);
+ cell_attribute_free (cell_attribute);
- info->attributes = g_slist_delete_link (info->attributes, node);
- }
+ info->attributes = g_slist_delete_link (info->attributes, node);
+ }
}
}
@@ -2342,24 +2362,24 @@ gtk_cell_area_attribute_disconnect (GtkCellArea *area,
* @is_expanded: whether @iter is expanded in the view and
* children are visible
*
- * Applies any connected attributes to the renderers in
+ * Applies any connected attributes to the renderers in
* @area by pulling the values from @tree_model.
*
* Since: 3.0
*/
void
gtk_cell_area_apply_attributes (GtkCellArea *area,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gboolean is_expander,
- gboolean is_expanded)
+ GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ gboolean is_expander,
+ gboolean is_expanded)
{
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_TREE_MODEL (tree_model));
g_return_if_fail (iter != NULL);
- g_signal_emit (area, cell_area_signals[SIGNAL_APPLY_ATTRIBUTES], 0,
- tree_model, iter, is_expander, is_expanded);
+ g_signal_emit (area, cell_area_signals[SIGNAL_APPLY_ATTRIBUTES], 0,
+ tree_model, iter, is_expander, is_expanded);
}
/**
@@ -2406,8 +2426,8 @@ gtk_cell_area_get_current_path_string (GtkCellArea *area)
*/
void
gtk_cell_area_class_install_cell_property (GtkCellAreaClass *aclass,
- guint property_id,
- GParamSpec *pspec)
+ guint property_id,
+ GParamSpec *pspec)
{
g_return_if_fail (GTK_IS_CELL_AREA_CLASS (aclass));
g_return_if_fail (G_IS_PARAM_SPEC (pspec));
@@ -2422,7 +2442,7 @@ gtk_cell_area_class_install_cell_property (GtkCellAreaClass *aclass,
if (g_param_spec_pool_lookup (cell_property_pool, pspec->name, G_OBJECT_CLASS_TYPE (aclass), TRUE))
{
g_warning (G_STRLOC ": class `%s' already contains a cell property named `%s'",
- G_OBJECT_CLASS_NAME (aclass), pspec->name);
+ G_OBJECT_CLASS_NAME (aclass), pspec->name);
return;
}
g_param_spec_ref (pspec);
@@ -2445,15 +2465,15 @@ gtk_cell_area_class_install_cell_property (GtkCellAreaClass *aclass,
*/
GParamSpec*
gtk_cell_area_class_find_cell_property (GtkCellAreaClass *aclass,
- const gchar *property_name)
+ const gchar *property_name)
{
g_return_val_if_fail (GTK_IS_CELL_AREA_CLASS (aclass), NULL);
g_return_val_if_fail (property_name != NULL, NULL);
return g_param_spec_pool_lookup (cell_property_pool,
- property_name,
- G_OBJECT_CLASS_TYPE (aclass),
- TRUE);
+ property_name,
+ G_OBJECT_CLASS_TYPE (aclass),
+ TRUE);
}
/**
@@ -2470,7 +2490,7 @@ gtk_cell_area_class_find_cell_property (GtkCellAreaClass *aclass,
*/
GParamSpec**
gtk_cell_area_class_list_cell_properties (GtkCellAreaClass *aclass,
- guint *n_properties)
+ guint *n_properties)
{
GParamSpec **pspecs;
guint n;
@@ -2478,8 +2498,8 @@ gtk_cell_area_class_list_cell_properties (GtkCellAreaClass *aclass,
g_return_val_if_fail (GTK_IS_CELL_AREA_CLASS (aclass), NULL);
pspecs = g_param_spec_pool_list (cell_property_pool,
- G_OBJECT_CLASS_TYPE (aclass),
- &n);
+ G_OBJECT_CLASS_TYPE (aclass),
+ &n);
if (n_properties)
*n_properties = n;
@@ -2501,9 +2521,9 @@ gtk_cell_area_class_list_cell_properties (GtkCellAreaClass *aclass,
*/
void
gtk_cell_area_add_with_properties (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *first_prop_name,
- ...)
+ GtkCellRenderer *renderer,
+ const gchar *first_prop_name,
+ ...)
{
GtkCellAreaClass *class;
@@ -2523,8 +2543,8 @@ gtk_cell_area_add_with_properties (GtkCellArea *area,
va_end (var_args);
}
else
- g_warning ("GtkCellAreaClass::add not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
+ g_warning ("GtkCellAreaClass::add not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
/**
@@ -2541,9 +2561,9 @@ gtk_cell_area_add_with_properties (GtkCellArea *area,
*/
void
gtk_cell_area_cell_set (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *first_prop_name,
- ...)
+ GtkCellRenderer *renderer,
+ const gchar *first_prop_name,
+ ...)
{
va_list var_args;
@@ -2569,9 +2589,9 @@ gtk_cell_area_cell_set (GtkCellArea *area,
*/
void
gtk_cell_area_cell_get (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *first_prop_name,
- ...)
+ GtkCellRenderer *renderer,
+ const gchar *first_prop_name,
+ ...)
{
va_list var_args;
@@ -2585,20 +2605,20 @@ gtk_cell_area_cell_get (GtkCellArea *area,
static inline void
area_get_cell_property (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GParamSpec *pspec,
- GValue *value)
+ GtkCellRenderer *renderer,
+ GParamSpec *pspec,
+ GValue *value)
{
GtkCellAreaClass *class = g_type_class_peek (pspec->owner_type);
-
+
class->get_cell_property (area, renderer, PARAM_SPEC_PARAM_ID (pspec), value, pspec);
}
static inline void
area_set_cell_property (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GParamSpec *pspec,
- const GValue *value)
+ GtkCellRenderer *renderer,
+ GParamSpec *pspec,
+ const GValue *value)
{
GValue tmp_value = { 0, };
GtkCellAreaClass *class = g_type_class_peek (pspec->owner_type);
@@ -2607,18 +2627,18 @@ area_set_cell_property (GtkCellArea *area,
g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
if (!g_value_transform (value, &tmp_value))
g_warning ("unable to set cell property `%s' of type `%s' from value of type `%s'",
- pspec->name,
- g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
- G_VALUE_TYPE_NAME (value));
+ pspec->name,
+ g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
+ G_VALUE_TYPE_NAME (value));
else if (g_param_value_validate (pspec, &tmp_value) && !(pspec->flags & G_PARAM_LAX_VALIDATION))
{
gchar *contents = g_strdup_value_contents (value);
g_warning ("value \"%s\" of type `%s' is invalid for property `%s' of type `%s'",
- contents,
- G_VALUE_TYPE_NAME (value),
- pspec->name,
- g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));
+ contents,
+ G_VALUE_TYPE_NAME (value),
+ pspec->name,
+ g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));
g_free (contents);
}
else
@@ -2642,9 +2662,9 @@ area_set_cell_property (GtkCellArea *area,
*/
void
gtk_cell_area_cell_set_valist (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *first_property_name,
- va_list var_args)
+ GtkCellRenderer *renderer,
+ const gchar *first_property_name,
+ va_list var_args)
{
const gchar *name;
@@ -2656,34 +2676,34 @@ gtk_cell_area_cell_set_valist (GtkCellArea *area,
{
GValue value = { 0, };
gchar *error = NULL;
- GParamSpec *pspec =
- g_param_spec_pool_lookup (cell_property_pool, name,
- G_OBJECT_TYPE (area), TRUE);
+ GParamSpec *pspec =
+ g_param_spec_pool_lookup (cell_property_pool, name,
+ G_OBJECT_TYPE (area), TRUE);
if (!pspec)
- {
- g_warning ("%s: cell area class `%s' has no cell property named `%s'",
- G_STRLOC, G_OBJECT_TYPE_NAME (area), name);
- break;
- }
+ {
+ g_warning ("%s: cell area class `%s' has no cell property named `%s'",
+ G_STRLOC, G_OBJECT_TYPE_NAME (area), name);
+ break;
+ }
if (!(pspec->flags & G_PARAM_WRITABLE))
- {
- g_warning ("%s: cell property `%s' of cell area class `%s' is not writable",
- G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
- break;
- }
+ {
+ g_warning ("%s: cell property `%s' of cell area class `%s' is not writable",
+ G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
+ break;
+ }
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
G_VALUE_COLLECT (&value, var_args, 0, &error);
if (error)
- {
- g_warning ("%s: %s", G_STRLOC, error);
- g_free (error);
-
- /* we purposely leak the value here, it might not be
- * in a sane state if an error condition occoured
- */
- break;
- }
+ {
+ g_warning ("%s: %s", G_STRLOC, error);
+ g_free (error);
+
+ /* we purposely leak the value here, it might not be
+ * in a sane state if an error condition occoured
+ */
+ break;
+ }
area_set_cell_property (area, renderer, pspec, &value);
g_value_unset (&value);
name = va_arg (var_args, gchar*);
@@ -2704,9 +2724,9 @@ gtk_cell_area_cell_set_valist (GtkCellArea *area,
*/
void
gtk_cell_area_cell_get_valist (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *first_property_name,
- va_list var_args)
+ GtkCellRenderer *renderer,
+ const gchar *first_property_name,
+ va_list var_args)
{
const gchar *name;
@@ -2721,30 +2741,30 @@ gtk_cell_area_cell_get_valist (GtkCellArea *area,
gchar *error;
pspec = g_param_spec_pool_lookup (cell_property_pool, name,
- G_OBJECT_TYPE (area), TRUE);
+ G_OBJECT_TYPE (area), TRUE);
if (!pspec)
- {
- g_warning ("%s: cell area class `%s' has no cell property named `%s'",
- G_STRLOC, G_OBJECT_TYPE_NAME (area), name);
- break;
- }
+ {
+ g_warning ("%s: cell area class `%s' has no cell property named `%s'",
+ G_STRLOC, G_OBJECT_TYPE_NAME (area), name);
+ break;
+ }
if (!(pspec->flags & G_PARAM_READABLE))
- {
- g_warning ("%s: cell property `%s' of cell area class `%s' is not readable",
- G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
- break;
- }
+ {
+ g_warning ("%s: cell property `%s' of cell area class `%s' is not readable",
+ G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
+ break;
+ }
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
area_get_cell_property (area, renderer, pspec, &value);
G_VALUE_LCOPY (&value, var_args, 0, &error);
if (error)
- {
- g_warning ("%s: %s", G_STRLOC, error);
- g_free (error);
- g_value_unset (&value);
- break;
- }
+ {
+ g_warning ("%s: %s", G_STRLOC, error);
+ g_free (error);
+ g_value_unset (&value);
+ break;
+ }
g_value_unset (&value);
name = va_arg (var_args, gchar*);
}
@@ -2763,9 +2783,9 @@ gtk_cell_area_cell_get_valist (GtkCellArea *area,
*/
void
gtk_cell_area_cell_set_property (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *property_name,
- const GValue *value)
+ GtkCellRenderer *renderer,
+ const gchar *property_name,
+ const GValue *value)
{
GParamSpec *pspec;
@@ -2773,15 +2793,15 @@ gtk_cell_area_cell_set_property (GtkCellArea *area,
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
g_return_if_fail (property_name != NULL);
g_return_if_fail (G_IS_VALUE (value));
-
+
pspec = g_param_spec_pool_lookup (cell_property_pool, property_name,
- G_OBJECT_TYPE (area), TRUE);
+ G_OBJECT_TYPE (area), TRUE);
if (!pspec)
g_warning ("%s: cell area class `%s' has no cell property named `%s'",
- G_STRLOC, G_OBJECT_TYPE_NAME (area), property_name);
+ G_STRLOC, G_OBJECT_TYPE_NAME (area), property_name);
else if (!(pspec->flags & G_PARAM_WRITABLE))
g_warning ("%s: cell property `%s' of cell area class `%s' is not writable",
- G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
+ G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
else
{
area_set_cell_property (area, renderer, pspec, value);
@@ -2801,9 +2821,9 @@ gtk_cell_area_cell_set_property (GtkCellArea *area,
*/
void
gtk_cell_area_cell_get_property (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *property_name,
- GValue *value)
+ GtkCellRenderer *renderer,
+ const gchar *property_name,
+ GValue *value)
{
GParamSpec *pspec;
@@ -2811,15 +2831,15 @@ gtk_cell_area_cell_get_property (GtkCellArea *area,
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
g_return_if_fail (property_name != NULL);
g_return_if_fail (G_IS_VALUE (value));
-
+
pspec = g_param_spec_pool_lookup (cell_property_pool, property_name,
- G_OBJECT_TYPE (area), TRUE);
+ G_OBJECT_TYPE (area), TRUE);
if (!pspec)
g_warning ("%s: cell area class `%s' has no cell property named `%s'",
- G_STRLOC, G_OBJECT_TYPE_NAME (area), property_name);
+ G_STRLOC, G_OBJECT_TYPE_NAME (area), property_name);
else if (!(pspec->flags & G_PARAM_READABLE))
g_warning ("%s: cell property `%s' of cell area class `%s' is not readable",
- G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
+ G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
else
{
GValue *prop_value, tmp_value = { 0, };
@@ -2827,31 +2847,31 @@ gtk_cell_area_cell_get_property (GtkCellArea *area,
/* auto-conversion of the callers value type
*/
if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec))
- {
- g_value_reset (value);
- prop_value = value;
- }
+ {
+ g_value_reset (value);
+ prop_value = value;
+ }
else if (!g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec), G_VALUE_TYPE (value)))
- {
- g_warning ("can't retrieve cell property `%s' of type `%s' as value of type `%s'",
- pspec->name,
- g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
- G_VALUE_TYPE_NAME (value));
- return;
- }
+ {
+ g_warning ("can't retrieve cell property `%s' of type `%s' as value of type `%s'",
+ pspec->name,
+ g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
+ G_VALUE_TYPE_NAME (value));
+ return;
+ }
else
- {
- g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
- prop_value = &tmp_value;
- }
+ {
+ g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
+ prop_value = &tmp_value;
+ }
area_get_cell_property (area, renderer, pspec, prop_value);
if (prop_value != value)
- {
- g_value_transform (prop_value, value);
- g_value_unset (&tmp_value);
- }
+ {
+ g_value_transform (prop_value, value);
+ g_value_unset (&tmp_value);
+ }
}
}
@@ -2897,7 +2917,7 @@ gtk_cell_area_is_activatable (GtkCellArea *area)
*/
gboolean
gtk_cell_area_focus (GtkCellArea *area,
- GtkDirectionType direction)
+ GtkDirectionType direction)
{
GtkCellAreaClass *class;
@@ -2908,8 +2928,8 @@ gtk_cell_area_focus (GtkCellArea *area,
if (class->focus)
return class->focus (area, direction);
- g_warning ("GtkCellAreaClass::focus not implemented for `%s'",
- g_type_name (G_TYPE_FROM_INSTANCE (area)));
+ g_warning ("GtkCellAreaClass::focus not implemented for `%s'",
+ g_type_name (G_TYPE_FROM_INSTANCE (area)));
return FALSE;
}
@@ -2934,11 +2954,11 @@ gtk_cell_area_focus (GtkCellArea *area,
*/
gboolean
gtk_cell_area_activate (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags,
- gboolean edit_only)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags,
+ gboolean edit_only)
{
g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
@@ -2961,7 +2981,7 @@ gtk_cell_area_activate (GtkCellArea *area,
*/
void
gtk_cell_area_set_focus_cell (GtkCellArea *area,
- GtkCellRenderer *renderer)
+ GtkCellRenderer *renderer)
{
GtkCellAreaPrivate *priv;
@@ -2973,12 +2993,12 @@ gtk_cell_area_set_focus_cell (GtkCellArea *area,
if (priv->focus_cell != renderer)
{
if (priv->focus_cell)
- g_object_unref (priv->focus_cell);
+ g_object_unref (priv->focus_cell);
priv->focus_cell = renderer;
if (priv->focus_cell)
- g_object_ref (priv->focus_cell);
+ g_object_ref (priv->focus_cell);
g_object_notify (G_OBJECT (area), "focus-cell");
}
@@ -2986,8 +3006,8 @@ gtk_cell_area_set_focus_cell (GtkCellArea *area,
/* Signal that the current focus renderer for this path changed
* (it may be that the focus cell did not change, but the row
* may have changed so we need to signal it) */
- g_signal_emit (area, cell_area_signals[SIGNAL_FOCUS_CHANGED], 0,
- priv->focus_cell, priv->current_path);
+ g_signal_emit (area, cell_area_signals[SIGNAL_FOCUS_CHANGED], 0,
+ priv->focus_cell, priv->current_path);
}
@@ -3025,7 +3045,7 @@ gtk_cell_area_get_focus_cell (GtkCellArea *area)
* @sibling: the #GtkCellRenderer to add to @renderer's focus area
*
* Adds @sibling to @renderer's focusable area, focus will be drawn
- * around @renderer and all of it's siblings if @renderer can
+ * around @renderer and all of it's siblings if @renderer can
* focus for a given row.
*
* Events handled by focus siblings can also activate the given
@@ -3035,8 +3055,8 @@ gtk_cell_area_get_focus_cell (GtkCellArea *area)
*/
void
gtk_cell_area_add_focus_sibling (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GtkCellRenderer *sibling)
+ GtkCellRenderer *renderer,
+ GtkCellRenderer *sibling)
{
GtkCellAreaPrivate *priv;
GList *siblings;
@@ -3072,16 +3092,16 @@ gtk_cell_area_add_focus_sibling (GtkCellArea *area,
* @area: a #GtkCellArea
* @renderer: the #GtkCellRenderer expected to have focus
* @sibling: the #GtkCellRenderer to remove from @renderer's focus area
- *
- * Removes @sibling from @renderer's focus sibling list
+ *
+ * Removes @sibling from @renderer's focus sibling list
* (see gtk_cell_area_add_focus_sibling()).
*
* Since: 3.0
*/
void
gtk_cell_area_remove_focus_sibling (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GtkCellRenderer *sibling)
+ GtkCellRenderer *renderer,
+ GtkCellRenderer *sibling)
{
GtkCellAreaPrivate *priv;
GList *siblings;
@@ -3109,7 +3129,7 @@ gtk_cell_area_remove_focus_sibling (GtkCellArea *area,
* @area: a #GtkCellArea
* @renderer: the #GtkCellRenderer expected to have focus
* @sibling: the #GtkCellRenderer to check against @renderer's sibling list
- *
+ *
* Returns %TRUE if @sibling is one of @renderer's focus siblings
* (see gtk_cell_area_add_focus_sibling()).
*
@@ -3117,8 +3137,8 @@ gtk_cell_area_remove_focus_sibling (GtkCellArea *area,
*/
gboolean
gtk_cell_area_is_focus_sibling (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GtkCellRenderer *sibling)
+ GtkCellRenderer *renderer,
+ GtkCellRenderer *sibling)
{
GtkCellAreaPrivate *priv;
GList *siblings, *l;
@@ -3136,7 +3156,7 @@ gtk_cell_area_is_focus_sibling (GtkCellArea *area,
GtkCellRenderer *a_sibling = l->data;
if (a_sibling == sibling)
- return TRUE;
+ return TRUE;
}
return FALSE;
@@ -3149,14 +3169,14 @@ gtk_cell_area_is_focus_sibling (GtkCellArea *area,
*
* Gets the focus sibling cell renderers for @renderer.
*
- * Return value: (element-type GtkCellRenderer) (transfer none): A #GList of #GtkCellRenderers.
+ * Return value: (element-type GtkCellRenderer) (transfer none): A #GList of #GtkCellRenderers.
* The returned list is internal and should not be freed.
*
* Since: 3.0
*/
const GList *
gtk_cell_area_get_focus_siblings (GtkCellArea *area,
- GtkCellRenderer *renderer)
+ GtkCellRenderer *renderer)
{
GtkCellAreaPrivate *priv;
@@ -3165,7 +3185,7 @@ gtk_cell_area_get_focus_siblings (GtkCellArea *area,
priv = area->priv;
- return g_hash_table_lookup (priv->focus_siblings, renderer);
+ return g_hash_table_lookup (priv->focus_siblings, renderer);
}
/**
@@ -3187,7 +3207,7 @@ gtk_cell_area_get_focus_siblings (GtkCellArea *area,
*/
GtkCellRenderer *
gtk_cell_area_get_focus_from_sibling (GtkCellArea *area,
- GtkCellRenderer *renderer)
+ GtkCellRenderer *renderer)
{
GtkCellRenderer *ret_renderer = NULL;
GList *renderers, *l;
@@ -3202,17 +3222,17 @@ gtk_cell_area_get_focus_from_sibling (GtkCellArea *area,
GtkCellRenderer *a_renderer = l->data;
const GList *list;
- for (list = gtk_cell_area_get_focus_siblings (area, a_renderer);
- list; list = list->next)
- {
- GtkCellRenderer *sibling_renderer = list->data;
-
- if (sibling_renderer == renderer)
- {
- ret_renderer = a_renderer;
- break;
- }
- }
+ for (list = gtk_cell_area_get_focus_siblings (area, a_renderer);
+ list; list = list->next)
+ {
+ GtkCellRenderer *sibling_renderer = list->data;
+
+ if (sibling_renderer == renderer)
+ {
+ ret_renderer = a_renderer;
+ break;
+ }
+ }
}
g_list_free (renderers);
@@ -3224,25 +3244,25 @@ gtk_cell_area_get_focus_from_sibling (GtkCellArea *area,
*************************************************************/
static void
gtk_cell_area_add_editable (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GtkCellEditable *editable,
- const GdkRectangle *cell_area)
+ GtkCellRenderer *renderer,
+ GtkCellEditable *editable,
+ const GdkRectangle *cell_area)
{
- g_signal_emit (area, cell_area_signals[SIGNAL_ADD_EDITABLE], 0,
- renderer, editable, cell_area, area->priv->current_path);
+ g_signal_emit (area, cell_area_signals[SIGNAL_ADD_EDITABLE], 0,
+ renderer, editable, cell_area, area->priv->current_path);
}
static void
gtk_cell_area_remove_editable (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GtkCellEditable *editable)
+ GtkCellRenderer *renderer,
+ GtkCellEditable *editable)
{
g_signal_emit (area, cell_area_signals[SIGNAL_REMOVE_EDITABLE], 0, renderer, editable);
}
static void
cell_area_remove_widget_cb (GtkCellEditable *editable,
- GtkCellArea *area)
+ GtkCellArea *area)
{
GtkCellAreaPrivate *priv = area->priv;
@@ -3259,7 +3279,7 @@ cell_area_remove_widget_cb (GtkCellEditable *editable,
static void
gtk_cell_area_set_edited_cell (GtkCellArea *area,
- GtkCellRenderer *renderer)
+ GtkCellRenderer *renderer)
{
GtkCellAreaPrivate *priv;
@@ -3271,12 +3291,12 @@ gtk_cell_area_set_edited_cell (GtkCellArea *area,
if (priv->edited_cell != renderer)
{
if (priv->edited_cell)
- g_object_unref (priv->edited_cell);
+ g_object_unref (priv->edited_cell);
priv->edited_cell = renderer;
if (priv->edited_cell)
- g_object_ref (priv->edited_cell);
+ g_object_ref (priv->edited_cell);
g_object_notify (G_OBJECT (area), "edited-cell");
}
@@ -3284,7 +3304,7 @@ gtk_cell_area_set_edited_cell (GtkCellArea *area,
static void
gtk_cell_area_set_edit_widget (GtkCellArea *area,
- GtkCellEditable *editable)
+ GtkCellEditable *editable)
{
GtkCellAreaPrivate *priv;
@@ -3296,22 +3316,22 @@ gtk_cell_area_set_edit_widget (GtkCellArea *area,
if (priv->edit_widget != editable)
{
if (priv->edit_widget)
- {
- g_signal_handler_disconnect (priv->edit_widget, priv->remove_widget_id);
+ {
+ g_signal_handler_disconnect (priv->edit_widget, priv->remove_widget_id);
- g_object_unref (priv->edit_widget);
- }
+ g_object_unref (priv->edit_widget);
+ }
priv->edit_widget = editable;
if (priv->edit_widget)
- {
- priv->remove_widget_id =
- g_signal_connect (priv->edit_widget, "remove-widget",
- G_CALLBACK (cell_area_remove_widget_cb), area);
+ {
+ priv->remove_widget_id =
+ g_signal_connect (priv->edit_widget, "remove-widget",
+ G_CALLBACK (cell_area_remove_widget_cb), area);
- g_object_ref (priv->edit_widget);
- }
+ g_object_ref (priv->edit_widget);
+ }
g_object_notify (G_OBJECT (area), "edit-widget");
}
@@ -3384,15 +3404,15 @@ gtk_cell_area_get_edit_widget (GtkCellArea *area)
*/
gboolean
gtk_cell_area_activate_cell (GtkCellArea *area,
- GtkWidget *widget,
- GtkCellRenderer *renderer,
- GdkEvent *event,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags)
+ GtkWidget *widget,
+ GtkCellRenderer *renderer,
+ GdkEvent *event,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags)
{
GtkCellRendererMode mode;
GtkCellAreaPrivate *priv;
-
+
g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), FALSE);
@@ -3405,12 +3425,12 @@ gtk_cell_area_activate_cell (GtkCellArea *area,
if (mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE)
{
if (gtk_cell_renderer_activate (renderer,
- event, widget,
- priv->current_path,
- cell_area,
- cell_area,
- flags))
- return TRUE;
+ event, widget,
+ priv->current_path,
+ cell_area,
+ cell_area,
+ flags))
+ return TRUE;
}
else if (mode == GTK_CELL_RENDERER_MODE_EDITABLE)
{
@@ -3418,43 +3438,43 @@ gtk_cell_area_activate_cell (GtkCellArea *area,
GdkRectangle inner_area;
gtk_cell_area_inner_cell_area (area, widget, cell_area, &inner_area);
-
+
editable_widget =
- gtk_cell_renderer_start_editing (renderer,
- event, widget,
- priv->current_path,
- &inner_area,
- &inner_area,
- flags);
-
+ gtk_cell_renderer_start_editing (renderer,
+ event, widget,
+ priv->current_path,
+ &inner_area,
+ &inner_area,
+ flags);
+
if (editable_widget != NULL)
- {
- g_return_val_if_fail (GTK_IS_CELL_EDITABLE (editable_widget), FALSE);
-
- gtk_cell_area_set_edited_cell (area, renderer);
- gtk_cell_area_set_edit_widget (area, editable_widget);
-
- /* Signal that editing started so that callers can get
- * a handle on the editable_widget */
- gtk_cell_area_add_editable (area, priv->focus_cell, editable_widget, cell_area);
-
- /* If the signal was successfully handled start the editing */
- if (gtk_widget_get_parent (GTK_WIDGET (editable_widget)))
- {
- gtk_cell_editable_start_editing (editable_widget, NULL);
- gtk_widget_grab_focus (GTK_WIDGET (editable_widget));
- }
- else
- {
- /* Otherwise clear the editing state and fire a warning */
- gtk_cell_area_set_edited_cell (area, NULL);
- gtk_cell_area_set_edit_widget (area, NULL);
-
- g_warning ("GtkCellArea::add-editable fired in the dark, no cell editing was started.");
- }
-
- return TRUE;
- }
+ {
+ g_return_val_if_fail (GTK_IS_CELL_EDITABLE (editable_widget), FALSE);
+
+ gtk_cell_area_set_edited_cell (area, renderer);
+ gtk_cell_area_set_edit_widget (area, editable_widget);
+
+ /* Signal that editing started so that callers can get
+ * a handle on the editable_widget */
+ gtk_cell_area_add_editable (area, priv->focus_cell, editable_widget, cell_area);
+
+ /* If the signal was successfully handled start the editing */
+ if (gtk_widget_get_parent (GTK_WIDGET (editable_widget)))
+ {
+ gtk_cell_editable_start_editing (editable_widget, NULL);
+ gtk_widget_grab_focus (GTK_WIDGET (editable_widget));
+ }
+ else
+ {
+ /* Otherwise clear the editing state and fire a warning */
+ gtk_cell_area_set_edited_cell (area, NULL);
+ gtk_cell_area_set_edit_widget (area, NULL);
+
+ g_warning ("GtkCellArea::add-editable fired in the dark, no cell editing was started.");
+ }
+
+ return TRUE;
+ }
}
return FALSE;
@@ -3475,7 +3495,7 @@ gtk_cell_area_activate_cell (GtkCellArea *area,
*/
void
gtk_cell_area_stop_editing (GtkCellArea *area,
- gboolean canceled)
+ gboolean canceled)
{
GtkCellAreaPrivate *priv;
@@ -3490,7 +3510,7 @@ gtk_cell_area_stop_editing (GtkCellArea *area,
/* Stop editing of the cell renderer */
gtk_cell_renderer_stop_editing (priv->edited_cell, canceled);
-
+
/* Remove any references to the editable widget */
gtk_cell_area_set_edited_cell (area, NULL);
gtk_cell_area_set_edit_widget (area, NULL);
@@ -3512,7 +3532,7 @@ gtk_cell_area_stop_editing (GtkCellArea *area,
* gtk_cell_area_inner_cell_area:
* @area: a #GtkCellArea
* @widget: the #GtkWidget that @area is rendering onto
- * @cell_area: the @widget relative coordinates where one of @area's cells
+ * @cell_area: the @widget relative coordinates where one of @area's cells
* is to be placed
* @inner_area: (out): the return location for the inner cell area
*
@@ -3524,9 +3544,9 @@ gtk_cell_area_stop_editing (GtkCellArea *area,
*/
void
gtk_cell_area_inner_cell_area (GtkCellArea *area,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- GdkRectangle *inner_area)
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ GdkRectangle *inner_area)
{
gint focus_line_width;
@@ -3566,12 +3586,12 @@ gtk_cell_area_inner_cell_area (GtkCellArea *area,
*/
void
gtk_cell_area_request_renderer (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GtkOrientation orientation,
- GtkWidget *widget,
- gint for_size,
- gint *minimum_size,
- gint *natural_size)
+ GtkCellRenderer *renderer,
+ GtkOrientation orientation,
+ GtkWidget *widget,
+ gint for_size,
+ gint *minimum_size,
+ gint *natural_size)
{
GtkCellAreaPrivate *priv;
gint focus_line_width;
@@ -3591,26 +3611,26 @@ gtk_cell_area_request_renderer (GtkCellArea *area,
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
if (for_size < 0)
- gtk_cell_renderer_get_preferred_width (renderer, widget, minimum_size, natural_size);
+ gtk_cell_renderer_get_preferred_width (renderer, widget, minimum_size, natural_size);
else
- {
- for_size = MAX (0, for_size - focus_line_width);
+ {
+ for_size = MAX (0, for_size - focus_line_width);
- gtk_cell_renderer_get_preferred_width_for_height (renderer, widget, for_size,
- minimum_size, natural_size);
- }
+ gtk_cell_renderer_get_preferred_width_for_height (renderer, widget, for_size,
+ minimum_size, natural_size);
+ }
}
else /* GTK_ORIENTATION_VERTICAL */
{
if (for_size < 0)
- gtk_cell_renderer_get_preferred_height (renderer, widget, minimum_size, natural_size);
+ gtk_cell_renderer_get_preferred_height (renderer, widget, minimum_size, natural_size);
else
- {
- for_size = MAX (0, for_size - focus_line_width);
+ {
+ for_size = MAX (0, for_size - focus_line_width);
- gtk_cell_renderer_get_preferred_height_for_width (renderer, widget, for_size,
- minimum_size, natural_size);
- }
+ gtk_cell_renderer_get_preferred_height_for_width (renderer, widget, for_size,
+ minimum_size, natural_size);
+ }
}
*minimum_size += focus_line_width;
diff --git a/gtk/gtkcellarea.h b/gtk/gtkcellarea.h
index f9c1c45..d8d06cf 100644
--- a/gtk/gtkcellarea.h
+++ b/gtk/gtkcellarea.h
@@ -34,10 +34,10 @@
G_BEGIN_DECLS
-#define GTK_TYPE_CELL_AREA (gtk_cell_area_get_type ())
-#define GTK_CELL_AREA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_AREA, GtkCellArea))
-#define GTK_CELL_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_AREA, GtkCellAreaClass))
-#define GTK_IS_CELL_AREA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_AREA))
+#define GTK_TYPE_CELL_AREA (gtk_cell_area_get_type ())
+#define GTK_CELL_AREA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_AREA, GtkCellArea))
+#define GTK_CELL_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_AREA, GtkCellAreaClass))
+#define GTK_IS_CELL_AREA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_AREA))
#define GTK_IS_CELL_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_AREA))
#define GTK_CELL_AREA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_AREA, GtkCellAreaClass))
@@ -49,7 +49,7 @@ typedef struct _GtkCellAreaContext GtkCellAreaContext;
/**
* GTK_CELL_AREA_WARN_INVALID_CELL_PROPERTY_ID:
* @object: the #GObject on which set_cell_property() or get_get_property()
- * was called
+ * was called
* @property_id: the numeric id of the property
* @pspec: the #GParamSpec of the property
*
@@ -70,26 +70,27 @@ typedef struct _GtkCellAreaContext GtkCellAreaContext;
* Return value: %TRUE to stop iterating over cells.
*/
typedef gboolean (*GtkCellCallback) (GtkCellRenderer *renderer,
- gpointer data);
+ gpointer data);
/**
* GtkCellAllocCallback:
* @renderer: the cell renderer to operate on
- * @cell_area: the area allocated to @renderer inside the rectangle provided to gtk_cell_area_foreach_alloc().
- * @cell_background: the background area for @renderer inside the background
- * area provided to gtk_cell_area_foreach_alloc().
+ * @cell_area: the area allocated to @renderer inside the rectangle
+ * provided to gtk_cell_area_foreach_alloc().
+ * @cell_background: the background area for @renderer inside the
+ * background area provided to gtk_cell_area_foreach_alloc().
* @data: user-supplied data
*
- * The type of the callback functions used for iterating over
- * the cell renderers and their allocated areas inside a #GtkCellArea,
+ * The type of the callback functions used for iterating over the
+ * cell renderers and their allocated areas inside a #GtkCellArea,
* see gtk_cell_area_foreach_alloc().
*
* Return value: %TRUE to stop iterating over cells.
*/
typedef gboolean (*GtkCellAllocCallback) (GtkCellRenderer *renderer,
- const GdkRectangle *cell_area,
- const GdkRectangle *cell_background,
- gpointer data);
+ const GdkRectangle *cell_area,
+ const GdkRectangle *cell_background,
+ gpointer data);
struct _GtkCellArea
@@ -105,60 +106,71 @@ struct _GtkCellArea
* GtkCellAreaClass:
* @add: adds a #GtkCellRenderer to the area.
* @remove: removes a #GtkCellRenderer from the area.
- * @foreach: Calls the #GtkCellCallback function on every #GtkCellRenderer in the area
- * with the provided user data until the callback returns %TRUE.
- * @foreach_alloc: Calls the #GtkCellAllocCallback function on every #GtkCellRenderer in the area
- * with the allocated area for the cell and the provided user data until the callback returns %TRUE.
- * @event: Handle an event in the area, this is generally used to activate a cell
- * at the event location for button events but can also be used to generically pass
- * events to #GtkWidgets drawn onto the area.
- * @render: Actually render the area's cells to the specified rectangle, @background_area
- * should be correctly distributed to the cells coresponding background areas.
- * @apply_attributes: Apply the cell attributes to the cells. This is implemented as a signal and
- * generally #GtkCellArea subclasses dont need to implement this since it's handled by the base
- * class but can be overridden to apply some custom attributes.
- * @create_context: Creates and returns a class specific #GtkCellAreaContext to store cell
- * alignment and allocation details for a said #GtkCellArea class.
- * @copy_context: Creates a new #GtkCellAreaContext in the same state as the passed @context
- * with any cell alignment data and allocations in tact.
- * @get_request_mode: This allows an area to tell its layouting widget whether it prefers to
- * be allocated in %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT mode.
- * @get_preferred_width: Calculates the minimum and natural width of the area's cells
- * with the current attributes applied while considering the particular layouting details
- * of the said #GtkCellArea. While requests are performed over a series of rows, alignments
- * and overall minimum and natural sizes should be stored in the corresponding #GtkCellAreaContext.
- * @get_preferred_height_for_width: Calculates the minimum and natural height for the area
- * if the passed @context would be allocated the given width. When implementing this virtual
- * method it is safe to assume that @context has already stored the aligned cell widths
- * for every #GtkTreeModel row that @context will be allocated for since this information
- * was stored at #GtkCellAreaClass.get_preferred_width() time. This virtual method should
- * also store any necessary alignments of cell heights for the case that the context is
- * allocated a height.
- * @get_preferred_height: Calculates the minimum and natural height of the area's cells
- * with the current attributes applied. Essentially this is the same as
- * #GtkCellAreaClass.get_preferred_width() only for areas that are being requested as
- * %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT.
- * @get_preferred_width_for_height: Calculates the minimum and natural width for the area
- * if the passed @context would be allocated the given height. The same as
- * #GtkCellAreaClass.get_preferred_height_for_width() only for handling requests in the
- * %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT mode.
- * @set_cell_property: This should be implemented to handle changes in child cell properties
- * for a given #GtkCellRenderer that were previously installed on the #GtkCellAreaClass with
- * gtk_cell_area_class_install_cell_property().
- * @get_cell_property: This should be implemented to report the values of child cell properties
- * for a given child #GtkCellRenderer.
- * @focus: This virtual method should be implemented to navigate focus from cell to cell
- * inside the #GtkCellArea. The #GtkCellArea should move focus from cell to cell inside
- * the area and return %FALSE if focus logically leaves the area with the following exceptions:
- * When the area contains no activatable cells, the entire area recieves focus. Focus should not
- * be given to cells that are actually "focus siblings" of other sibling cells
- * (see gtk_cell_area_get_focus_from_sibling()). Focus is set by calling gtk_cell_area_set_focus_cell().
- * @is_activatable: Returns whether the #GtkCellArea can respond to #GtkCellAreaClass.activate(),
- * usually this does not need to be implemented since the base class takes care of this however
- * it can be enhanced if the #GtkCellArea subclass can handle activation in other ways than
- * activating its #GtkCellRenderers.
- * @activate: This is called when the layouting widget rendering the #GtkCellArea activates
- * the focus cell (see gtk_cell_area_get_focus_cell()).
+ * @foreach: calls the #GtkCellCallback function on every #GtkCellRenderer in
+ * the area with the provided user data until the callback returns %TRUE.
+ * @foreach_alloc: Calls the #GtkCellAllocCallback function on every
+ * #GtkCellRenderer in the area with the allocated area for the cell
+ * and the provided user data until the callback returns %TRUE.
+ * @event: Handle an event in the area, this is generally used to activate
+ * a cell at the event location for button events but can also be used
+ * to generically pass events to #GtkWidgets drawn onto the area.
+ * @render: Actually render the area's cells to the specified rectangle,
+ * @background_area should be correctly distributed to the cells
+ * corresponding background areas.
+ * @apply_attributes: Apply the cell attributes to the cells. This is
+ * implemented as a signal and generally #GtkCellArea subclasses don't
+ * need to implement it since it is handled by the base class.
+ * @create_context: Creates and returns a class specific #GtkCellAreaContext
+ * to store cell alignment and allocation details for a said #GtkCellArea
+ * class.
+ * @copy_context: Creates a new #GtkCellAreaContext in the same state as
+ * the passed @context with any cell alignment data and allocations intact.
+ * @get_request_mode: This allows an area to tell its layouting widget whether
+ * it prefers to be allocated in %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or
+ * %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT mode.
+ * @get_preferred_width: Calculates the minimum and natural width of the
+ * areas cells with the current attributes applied while considering
+ * the particular layouting details of the said #GtkCellArea. While
+ * requests are performed over a series of rows, alignments and overall
+ * minimum and natural sizes should be stored in the corresponding
+ * #GtkCellAreaContext.
+ * @get_preferred_height_for_width: Calculates the minimum and natural height
+ * for the area if the passed @context would be allocated the given width.
+ * When implementing this virtual method it is safe to assume that @context
+ * has already stored the aligned cell widths for every #GtkTreeModel row
+ * that @context will be allocated for since this information was stored
+ * at #GtkCellAreaClass.get_preferred_width() time. This virtual method
+ * should also store any necessary alignments of cell heights for the
+ * case that the context is allocated a height.
+ * @get_preferred_height: Calculates the minimum and natural height of the
+ * areas cells with the current attributes applied. Essentially this is
+ * the same as #GtkCellAreaClass.get_preferred_width() only for areas
+ * that are being requested as %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT.
+ * @get_preferred_width_for_height: Calculates the minimum and natural width
+ * for the area if the passed @context would be allocated the given
+ * height. The same as #GtkCellAreaClass.get_preferred_height_for_width()
+ * only for handling requests in the %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT
+ * mode.
+ * @set_cell_property: This should be implemented to handle changes in child
+ * cell properties for a given #GtkCellRenderer that were previously
+ * installed on the #GtkCellAreaClass with gtk_cell_area_class_install_cell_property().
+ * @get_cell_property: This should be implemented to report the values of
+ * child cell properties for a given child #GtkCellRenderer.
+ * @focus: This virtual method should be implemented to navigate focus from
+ * cell to cell inside the #GtkCellArea. The #GtkCellArea should move
+ * focus from cell to cell inside the area and return %FALSE if focus
+ * logically leaves the area with the following exceptions: When the
+ * area contains no activatable cells, the entire area recieves focus.
+ * Focus should not be given to cells that are actually "focus siblings"
+ * of other sibling cells (see gtk_cell_area_get_focus_from_sibling()).
+ * Focus is set by calling gtk_cell_area_set_focus_cell().
+ * @is_activatable: Returns whether the #GtkCellArea can respond to
+ * #GtkCellAreaClass.activate(), usually this does not need to be
+ * implemented since the base class takes care of this however it can
+ * be enhanced if the #GtkCellArea subclass can handle activation in
+ * other ways than activating its #GtkCellRenderers.
+ * @activate: This is called when the layouting widget rendering the
+ * #GtkCellArea activates the focus cell (see gtk_cell_area_get_focus_cell()).
*/
struct _GtkCellAreaClass
{
@@ -169,62 +181,62 @@ struct _GtkCellAreaClass
/* Basic methods */
void (* add) (GtkCellArea *area,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
void (* remove) (GtkCellArea *area,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
void (* foreach) (GtkCellArea *area,
- GtkCellCallback callback,
- gpointer callback_data);
+ GtkCellCallback callback,
+ gpointer callback_data);
void (* foreach_alloc) (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- const GdkRectangle *background_area,
- GtkCellAllocCallback callback,
- gpointer callback_data);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ const GdkRectangle *background_area,
+ GtkCellAllocCallback callback,
+ gpointer callback_data);
gint (* event) (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- GdkEvent *event,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ GdkEvent *event,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags);
void (* render) (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- cairo_t *cr,
- const GdkRectangle *background_area,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags,
- gboolean paint_focus);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ cairo_t *cr,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags,
+ gboolean paint_focus);
void (* apply_attributes) (GtkCellArea *area,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gboolean is_expander,
- gboolean is_expanded);
+ GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ gboolean is_expander,
+ gboolean is_expanded);
/* Geometry */
GtkCellAreaContext *(* create_context) (GtkCellArea *area);
GtkCellAreaContext *(* copy_context) (GtkCellArea *area,
- GtkCellAreaContext *context);
+ GtkCellAreaContext *context);
GtkSizeRequestMode (* get_request_mode) (GtkCellArea *area);
void (* get_preferred_width) (GtkCellArea *area,
- GtkCellAreaContext *context,
+ GtkCellAreaContext *context,
GtkWidget *widget,
gint *minimum_width,
gint *natural_width);
void (* get_preferred_height_for_width) (GtkCellArea *area,
- GtkCellAreaContext *context,
+ GtkCellAreaContext *context,
GtkWidget *widget,
gint width,
gint *minimum_height,
gint *natural_height);
void (* get_preferred_height) (GtkCellArea *area,
- GtkCellAreaContext *context,
+ GtkCellAreaContext *context,
GtkWidget *widget,
gint *minimum_height,
gint *natural_height);
void (* get_preferred_width_for_height) (GtkCellArea *area,
- GtkCellAreaContext *context,
+ GtkCellAreaContext *context,
GtkWidget *widget,
gint height,
gint *minimum_width,
@@ -232,26 +244,26 @@ struct _GtkCellAreaClass
/* Cell Properties */
void (* set_cell_property) (GtkCellArea *area,
- GtkCellRenderer *renderer,
- guint property_id,
- const GValue *value,
- GParamSpec *pspec);
+ GtkCellRenderer *renderer,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec);
void (* get_cell_property) (GtkCellArea *area,
- GtkCellRenderer *renderer,
- guint property_id,
- GValue *value,
- GParamSpec *pspec);
+ GtkCellRenderer *renderer,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec);
/* Focus */
gboolean (* focus) (GtkCellArea *area,
- GtkDirectionType direction);
+ GtkDirectionType direction);
gboolean (* is_activatable) (GtkCellArea *area);
gboolean (* activate) (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags,
- gboolean edit_only);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags,
+ gboolean edit_only);
/*< private >*/
@@ -270,193 +282,193 @@ GType gtk_cell_area_get_type (void) G_GNUC
/* Basic methods */
void gtk_cell_area_add (GtkCellArea *area,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
void gtk_cell_area_remove (GtkCellArea *area,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
gboolean gtk_cell_area_has_renderer (GtkCellArea *area,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
void gtk_cell_area_foreach (GtkCellArea *area,
- GtkCellCallback callback,
- gpointer callback_data);
+ GtkCellCallback callback,
+ gpointer callback_data);
void gtk_cell_area_foreach_alloc (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- const GdkRectangle *background_area,
- GtkCellAllocCallback callback,
- gpointer callback_data);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ const GdkRectangle *background_area,
+ GtkCellAllocCallback callback,
+ gpointer callback_data);
gint gtk_cell_area_event (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- GdkEvent *event,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ GdkEvent *event,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags);
void gtk_cell_area_render (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- cairo_t *cr,
- const GdkRectangle *background_area,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags,
- gboolean paint_focus);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ cairo_t *cr,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags,
+ gboolean paint_focus);
void gtk_cell_area_set_style_detail (GtkCellArea *area,
- const gchar *detail);
+ const gchar *detail);
G_CONST_RETURN gchar *gtk_cell_area_get_style_detail (GtkCellArea *area);
void gtk_cell_area_get_cell_allocation (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- GtkCellRenderer *renderer,
- const GdkRectangle *cell_area,
- GdkRectangle *allocation);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ GtkCellRenderer *renderer,
+ const GdkRectangle *cell_area,
+ GdkRectangle *allocation);
GtkCellRenderer *gtk_cell_area_get_cell_at_position (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- gint x,
- gint y,
- GdkRectangle *alloc_area);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ gint x,
+ gint y,
+ GdkRectangle *alloc_area);
/* Geometry */
GtkCellAreaContext *gtk_cell_area_create_context (GtkCellArea *area);
GtkCellAreaContext *gtk_cell_area_copy_context (GtkCellArea *area,
- GtkCellAreaContext *context);
+ GtkCellAreaContext *context);
GtkSizeRequestMode gtk_cell_area_get_request_mode (GtkCellArea *area);
void gtk_cell_area_get_preferred_width (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint *minimum_width,
- gint *natural_width);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint *minimum_width,
+ gint *natural_width);
void gtk_cell_area_get_preferred_height_for_width (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint width,
+ gint *minimum_height,
+ gint *natural_height);
void gtk_cell_area_get_preferred_height (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint *minimum_height,
- gint *natural_height);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint *minimum_height,
+ gint *natural_height);
void gtk_cell_area_get_preferred_width_for_height (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint height,
+ gint *minimum_width,
+ gint *natural_width);
G_CONST_RETURN gchar *gtk_cell_area_get_current_path_string (GtkCellArea *area);
/* Attributes */
void gtk_cell_area_apply_attributes (GtkCellArea *area,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gboolean is_expander,
- gboolean is_expanded);
+ GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ gboolean is_expander,
+ gboolean is_expanded);
void gtk_cell_area_attribute_connect (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *attribute,
- gint column);
+ GtkCellRenderer *renderer,
+ const gchar *attribute,
+ gint column);
void gtk_cell_area_attribute_disconnect (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *attribute);
+ GtkCellRenderer *renderer,
+ const gchar *attribute);
/* Cell Properties */
void gtk_cell_area_class_install_cell_property (GtkCellAreaClass *aclass,
- guint property_id,
- GParamSpec *pspec);
+ guint property_id,
+ GParamSpec *pspec);
GParamSpec* gtk_cell_area_class_find_cell_property (GtkCellAreaClass *aclass,
- const gchar *property_name);
+ const gchar *property_name);
GParamSpec** gtk_cell_area_class_list_cell_properties (GtkCellAreaClass *aclass,
- guint *n_properties);
+ guint *n_properties);
void gtk_cell_area_add_with_properties (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *first_prop_name,
- ...) G_GNUC_NULL_TERMINATED;
+ GtkCellRenderer *renderer,
+ const gchar *first_prop_name,
+ ...) G_GNUC_NULL_TERMINATED;
void gtk_cell_area_cell_set (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *first_prop_name,
- ...) G_GNUC_NULL_TERMINATED;
+ GtkCellRenderer *renderer,
+ const gchar *first_prop_name,
+ ...) G_GNUC_NULL_TERMINATED;
void gtk_cell_area_cell_get (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *first_prop_name,
- ...) G_GNUC_NULL_TERMINATED;
+ GtkCellRenderer *renderer,
+ const gchar *first_prop_name,
+ ...) G_GNUC_NULL_TERMINATED;
void gtk_cell_area_cell_set_valist (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *first_property_name,
- va_list var_args);
+ GtkCellRenderer *renderer,
+ const gchar *first_property_name,
+ va_list var_args);
void gtk_cell_area_cell_get_valist (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *first_property_name,
- va_list var_args);
+ GtkCellRenderer *renderer,
+ const gchar *first_property_name,
+ va_list var_args);
void gtk_cell_area_cell_set_property (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *property_name,
- const GValue *value);
+ GtkCellRenderer *renderer,
+ const gchar *property_name,
+ const GValue *value);
void gtk_cell_area_cell_get_property (GtkCellArea *area,
- GtkCellRenderer *renderer,
- const gchar *property_name,
- GValue *value);
+ GtkCellRenderer *renderer,
+ const gchar *property_name,
+ GValue *value);
/* Focus */
gboolean gtk_cell_area_is_activatable (GtkCellArea *area);
gboolean gtk_cell_area_activate (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags,
- gboolean edit_only);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags,
+ gboolean edit_only);
gboolean gtk_cell_area_focus (GtkCellArea *area,
- GtkDirectionType direction);
+ GtkDirectionType direction);
void gtk_cell_area_set_focus_cell (GtkCellArea *area,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
GtkCellRenderer *gtk_cell_area_get_focus_cell (GtkCellArea *area);
/* Focus siblings */
void gtk_cell_area_add_focus_sibling (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GtkCellRenderer *sibling);
+ GtkCellRenderer *renderer,
+ GtkCellRenderer *sibling);
void gtk_cell_area_remove_focus_sibling (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GtkCellRenderer *sibling);
+ GtkCellRenderer *renderer,
+ GtkCellRenderer *sibling);
gboolean gtk_cell_area_is_focus_sibling (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GtkCellRenderer *sibling);
+ GtkCellRenderer *renderer,
+ GtkCellRenderer *sibling);
G_CONST_RETURN GList *gtk_cell_area_get_focus_siblings (GtkCellArea *area,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
GtkCellRenderer *gtk_cell_area_get_focus_from_sibling (GtkCellArea *area,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
/* Cell Activation/Editing */
GtkCellRenderer *gtk_cell_area_get_edited_cell (GtkCellArea *area);
GtkCellEditable *gtk_cell_area_get_edit_widget (GtkCellArea *area);
gboolean gtk_cell_area_activate_cell (GtkCellArea *area,
- GtkWidget *widget,
- GtkCellRenderer *renderer,
- GdkEvent *event,
- const GdkRectangle *cell_area,
- GtkCellRendererState flags);
+ GtkWidget *widget,
+ GtkCellRenderer *renderer,
+ GdkEvent *event,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags);
void gtk_cell_area_stop_editing (GtkCellArea *area,
- gboolean canceled);
+ gboolean canceled);
/* Functions for area implementations */
/* Distinguish the inner cell area from the whole requested area including margins */
void gtk_cell_area_inner_cell_area (GtkCellArea *area,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- GdkRectangle *inner_area);
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ GdkRectangle *inner_area);
/* Request the size of a cell while respecting the cell margins (requests are margin inclusive) */
void gtk_cell_area_request_renderer (GtkCellArea *area,
- GtkCellRenderer *renderer,
- GtkOrientation orientation,
- GtkWidget *widget,
- gint for_size,
- gint *minimum_size,
- gint *natural_size);
+ GtkCellRenderer *renderer,
+ GtkOrientation orientation,
+ GtkWidget *widget,
+ gint for_size,
+ gint *minimum_size,
+ gint *natural_size);
G_END_DECLS
diff --git a/gtk/gtkcellareabox.c b/gtk/gtkcellareabox.c
index b1818ec..90a0a07 100644
--- a/gtk/gtkcellareabox.c
+++ b/gtk/gtkcellareabox.c
@@ -24,25 +24,27 @@
/**
* SECTION:gtkcellareabox
- * @Short_Description: A cell area that renders GtkCellRenderers into a row or a column
+ * @Short_Description: A cell area that renders GtkCellRenderers
+ * into a row or a column
* @Title: GtkCellAreaBox
*
- * The #GtkCellAreaBox renders cell renderers into a row or a column depending on
- * its #GtkOrientation.
+ * The #GtkCellAreaBox renders cell renderers into a row or a column
+ * depending on its #GtkOrientation.
*
* GtkCellAreaBox uses a notion of <emphasis>packing</emphasis>. Packing
- * refers to adding cell renderers with reference to a particular position
+ * refers to adding cell renderers with reference to a particular position
* in a #GtkCellAreaBox. There are two reference positions: the
* <emphasis>start</emphasis> and the <emphasis>end</emphasis> of the box.
- * When the #GtkCellAreaBox is oriented in the %GTK_ORIENTATION_VERTICAL orientation,
- * the start is defined as the top of the box and the end is defined as the bottom.
- * In the %GTK_ORIENTATION_HORIZONTAL orientation start is defined as the
- * left side and the end is defined as the right side.
+ * When the #GtkCellAreaBox is oriented in the %GTK_ORIENTATION_VERTICAL
+ * orientation, the start is defined as the top of the box and the end is
+ * defined as the bottom. In the %GTK_ORIENTATION_HORIZONTAL orientation
+ * start is defined as the left side and the end is defined as the right
+ * side.
*
- * Alignments of #GtkCellRenderers rendered in adjacent rows can be configured
- * by configuring the #GtkCellAreaBox:align child cell property with
- * gtk_cell_area_cell_set_property() or by specifying the "align" argument
- * to gtk_cell_area_box_pack_start() and gtk_cell_area_box_pack_end().
+ * Alignments of #GtkCellRenderers rendered in adjacent rows can be
+ * configured by configuring the #GtkCellAreaBox:align child cell property
+ * with gtk_cell_area_cell_set_property() or by specifying the "align"
+ * argument to gtk_cell_area_box_pack_start() and gtk_cell_area_box_pack_end().
*/
#include "config.h"
@@ -58,82 +60,82 @@
static void gtk_cell_area_box_finalize (GObject *object);
static void gtk_cell_area_box_dispose (GObject *object);
static void gtk_cell_area_box_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec);
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
static void gtk_cell_area_box_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec);
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
/* GtkCellAreaClass */
static void gtk_cell_area_box_add (GtkCellArea *area,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
static void gtk_cell_area_box_remove (GtkCellArea *area,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
static void gtk_cell_area_box_foreach (GtkCellArea *area,
- GtkCellCallback callback,
- gpointer callback_data);
+ GtkCellCallback callback,
+ gpointer callback_data);
static void gtk_cell_area_box_foreach_alloc (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- const GdkRectangle *background_area,
- GtkCellAllocCallback callback,
- gpointer callback_data);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ const GdkRectangle *background_area,
+ GtkCellAllocCallback callback,
+ gpointer callback_data);
static void gtk_cell_area_box_set_cell_property (GtkCellArea *area,
- GtkCellRenderer *renderer,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec);
+ GtkCellRenderer *renderer,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
static void gtk_cell_area_box_get_cell_property (GtkCellArea *area,
- GtkCellRenderer *renderer,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec);
+ GtkCellRenderer *renderer,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
static GtkCellAreaContext *gtk_cell_area_box_create_context (GtkCellArea *area);
static GtkCellAreaContext *gtk_cell_area_box_copy_context (GtkCellArea *area,
- GtkCellAreaContext *context);
+ GtkCellAreaContext *context);
static GtkSizeRequestMode gtk_cell_area_box_get_request_mode (GtkCellArea *area);
static void gtk_cell_area_box_get_preferred_width (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint *minimum_width,
- gint *natural_width);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint *minimum_width,
+ gint *natural_width);
static void gtk_cell_area_box_get_preferred_height (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint *minimum_height,
- gint *natural_height);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint *minimum_height,
+ gint *natural_height);
static void gtk_cell_area_box_get_preferred_height_for_width (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint width,
+ gint *minimum_height,
+ gint *natural_height);
static void gtk_cell_area_box_get_preferred_width_for_height (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint height,
+ gint *minimum_width,
+ gint *natural_width);
static gboolean gtk_cell_area_box_focus (GtkCellArea *area,
- GtkDirectionType direction);
+ GtkDirectionType direction);
/* GtkCellLayoutIface */
static void gtk_cell_area_box_cell_layout_init (GtkCellLayoutIface *iface);
static void gtk_cell_area_box_layout_pack_start (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer,
- gboolean expand);
+ GtkCellRenderer *renderer,
+ gboolean expand);
static void gtk_cell_area_box_layout_pack_end (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer,
- gboolean expand);
+ GtkCellRenderer *renderer,
+ gboolean expand);
static void gtk_cell_area_box_layout_reorder (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer,
- gint position);
+ GtkCellRenderer *renderer,
+ gint position);
static void gtk_cell_area_box_focus_changed (GtkCellArea *area,
- GParamSpec *pspec,
- GtkCellAreaBox *box);
+ GParamSpec *pspec,
+ GtkCellAreaBox *box);
/* CellInfo/CellGroup metadata handling and convenience functions */
@@ -141,8 +143,8 @@ typedef struct {
GtkCellRenderer *renderer;
guint expand : 1; /* Whether the cell expands */
- guint pack : 1; /* Whether the cell is packed from the start or end */
- guint align : 1; /* Whether to align this cell's position with adjacent rows */
+ guint pack : 1; /* Whether it is packed from the start or end */
+ guint align : 1; /* Whether to align its position with adjacent rows */
} CellInfo;
typedef struct {
@@ -160,31 +162,31 @@ typedef struct {
gint size;
} AllocatedCell;
-static CellInfo *cell_info_new (GtkCellRenderer *renderer,
- GtkPackType pack,
- gboolean expand,
- gboolean align);
+static CellInfo *cell_info_new (GtkCellRenderer *renderer,
+ GtkPackType pack,
+ gboolean expand,
+ gboolean align);
static void cell_info_free (CellInfo *info);
static gint cell_info_find (CellInfo *info,
- GtkCellRenderer *renderer);
+ GtkCellRenderer *renderer);
static AllocatedCell *allocated_cell_new (GtkCellRenderer *renderer,
- gint position,
- gint size);
+ gint position,
+ gint size);
static void allocated_cell_free (AllocatedCell *cell);
static GList *list_consecutive_cells (GtkCellAreaBox *box);
static gint count_expand_groups (GtkCellAreaBox *box);
static void context_weak_notify (GtkCellAreaBox *box,
- GtkCellAreaBoxContext *dead_context);
+ GtkCellAreaBoxContext *dead_context);
static void reset_contexts (GtkCellAreaBox *box);
static void init_context_groups (GtkCellAreaBox *box);
static void init_context_group (GtkCellAreaBox *box,
- GtkCellAreaBoxContext *context);
+ GtkCellAreaBoxContext *context);
static GSList *get_allocated_cells (GtkCellAreaBox *box,
- GtkCellAreaBoxContext *context,
- GtkWidget *widget,
- gint width,
- gint height);
+ GtkCellAreaBoxContext *context,
+ GtkWidget *widget,
+ gint width,
+ gint height);
struct _GtkCellAreaBoxPrivate
@@ -193,7 +195,8 @@ struct _GtkCellAreaBoxPrivate
/* We hold on to the previously focused cell when navigating
* up and down in a horizontal box (or left and right on a vertical one)
- * this way we always re-enter the last focused cell. */
+ * this way we always re-enter the last focused cell.
+ */
GtkCellRenderer *last_focus_cell;
gulong focus_cell_id;
@@ -205,7 +208,8 @@ struct _GtkCellAreaBoxPrivate
gint spacing;
/* We hold on to the rtl state from a widget we are requested for
- * so that we can navigate focus correctly */
+ * so that we can navigate focus correctly
+ */
gboolean rtl;
};
@@ -223,12 +227,12 @@ enum {
};
G_DEFINE_TYPE_WITH_CODE (GtkCellAreaBox, gtk_cell_area_box, GTK_TYPE_CELL_AREA,
- G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
- gtk_cell_area_box_cell_layout_init)
- G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL));
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
+ gtk_cell_area_box_cell_layout_init)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL));
-#define OPPOSITE_ORIENTATION(orientation) \
- ((orientation) == GTK_ORIENTATION_HORIZONTAL ? \
+#define OPPOSITE_ORIENTATION(orientation) \
+ ((orientation) == GTK_ORIENTATION_HORIZONTAL ? \
GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL)
static void
@@ -249,12 +253,14 @@ gtk_cell_area_box_init (GtkCellAreaBox *box)
priv->rtl = FALSE;
/* Watch whenever focus is given to a cell, even if it's not with keynav,
- * this way we remember upon entry of the area where focus was last time around */
- priv->focus_cell_id = g_signal_connect (box, "notify::focus-cell",
- G_CALLBACK (gtk_cell_area_box_focus_changed), box);
+ * this way we remember upon entry of the area where focus was last time
+ * around
+ */
+ priv->focus_cell_id = g_signal_connect (box, "notify::focus-cell",
+ G_CALLBACK (gtk_cell_area_box_focus_changed), box);
}
-static void
+static void
gtk_cell_area_box_class_init (GtkCellAreaBoxClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS (class);
@@ -273,7 +279,7 @@ gtk_cell_area_box_class_init (GtkCellAreaBoxClass *class)
area_class->foreach_alloc = gtk_cell_area_box_foreach_alloc;
area_class->set_cell_property = gtk_cell_area_box_set_cell_property;
area_class->get_cell_property = gtk_cell_area_box_get_cell_property;
-
+
area_class->create_context = gtk_cell_area_box_create_context;
area_class->copy_context = gtk_cell_area_box_copy_context;
area_class->get_request_mode = gtk_cell_area_box_get_request_mode;
@@ -297,31 +303,31 @@ gtk_cell_area_box_class_init (GtkCellAreaBoxClass *class)
g_object_class_install_property (object_class,
PROP_SPACING,
g_param_spec_int ("spacing",
- P_("Spacing"),
- P_("Space which is inserted between cells"),
- 0,
- G_MAXINT,
- 0,
- GTK_PARAM_READWRITE));
+ P_("Spacing"),
+ P_("Space which is inserted between cells"),
+ 0,
+ G_MAXINT,
+ 0,
+ GTK_PARAM_READWRITE));
/* Cell Properties */
/**
* GtkCellAreaBox:expand:
*
- * Whether the cell renderer should receive extra space when the area receives
- * more than its natural size.
+ * Whether the cell renderer should receive extra space
+ * when the area receives more than its natural size.
*
* Since: 3.0
*/
gtk_cell_area_class_install_cell_property (area_class,
- CELL_PROP_EXPAND,
- g_param_spec_boolean
- ("expand",
- P_("Expand"),
- P_("Whether the cell expands"),
- FALSE,
- GTK_PARAM_READWRITE));
-
+ CELL_PROP_EXPAND,
+ g_param_spec_boolean
+ ("expand",
+ P_("Expand"),
+ P_("Whether the cell expands"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+
/**
* GtkCellAreaBox:align:
*
@@ -330,31 +336,31 @@ gtk_cell_area_box_class_init (GtkCellAreaBoxClass *class)
* Since: 3.0
*/
gtk_cell_area_class_install_cell_property (area_class,
- CELL_PROP_ALIGN,
- g_param_spec_boolean
- ("align",
- P_("Align"),
- P_("Whether cell should align with adjacent rows"),
- TRUE,
- GTK_PARAM_READWRITE));
+ CELL_PROP_ALIGN,
+ g_param_spec_boolean
+ ("align",
+ P_("Align"),
+ P_("Whether cell should align with adjacent rows"),
+ TRUE,
+ GTK_PARAM_READWRITE));
/**
* GtkCellAreaBox:pack-type:
*
- * A GtkPackType indicating whether the cell renderer is packed with reference to the
- * start or end of the area.
+ * A GtkPackType indicating whether the cell renderer is packed
+ * with reference to the start or end of the area.
*
* Since: 3.0
*/
gtk_cell_area_class_install_cell_property (area_class,
- CELL_PROP_PACK_TYPE,
- g_param_spec_enum
- ("pack-type",
- P_("Pack Type"),
- P_("A GtkPackType indicating whether the cell is packed with "
- "reference to the start or end of the cell area"),
- GTK_TYPE_PACK_TYPE, GTK_PACK_START,
- GTK_PARAM_READWRITE));
+ CELL_PROP_PACK_TYPE,
+ g_param_spec_enum
+ ("pack-type",
+ P_("Pack Type"),
+ P_("A GtkPackType indicating whether the cell is packed with "
+ "reference to the start or end of the cell area"),
+ GTK_TYPE_PACK_TYPE, GTK_PACK_START,
+ GTK_PARAM_READWRITE));
g_type_class_add_private (object_class, sizeof (GtkCellAreaBoxPrivate));
}
@@ -364,13 +370,13 @@ gtk_cell_area_box_class_init (GtkCellAreaBoxClass *class)
* CellInfo/CellGroup basics and convenience functions *
*************************************************************/
static CellInfo *
-cell_info_new (GtkCellRenderer *renderer,
- GtkPackType pack,
- gboolean expand,
- gboolean align)
+cell_info_new (GtkCellRenderer *renderer,
+ GtkPackType pack,
+ gboolean expand,
+ gboolean align)
{
CellInfo *info = g_slice_new (CellInfo);
-
+
info->renderer = g_object_ref_sink (renderer);
info->pack = pack;
info->expand = expand;
@@ -389,15 +395,15 @@ cell_info_free (CellInfo *info)
static gint
cell_info_find (CellInfo *info,
- GtkCellRenderer *renderer)
+ GtkCellRenderer *renderer)
{
return (info->renderer == renderer) ? 0 : -1;
}
static AllocatedCell *
allocated_cell_new (GtkCellRenderer *renderer,
- gint position,
- gint size)
+ gint position,
+ gint size)
{
AllocatedCell *cell = g_slice_new (AllocatedCell);
@@ -421,23 +427,23 @@ list_consecutive_cells (GtkCellAreaBox *box)
GList *l, *consecutive_cells = NULL, *pack_end_cells = NULL;
CellInfo *info;
- /* List cells in consecutive order taking their
- * PACK_START/PACK_END options into account
+ /* List cells in consecutive order taking their
+ * PACK_START/PACK_END options into account
*/
for (l = priv->cells; l; l = l->next)
{
info = l->data;
-
+
if (info->pack == GTK_PACK_START)
- consecutive_cells = g_list_prepend (consecutive_cells, info);
+ consecutive_cells = g_list_prepend (consecutive_cells, info);
}
for (l = priv->cells; l; l = l->next)
{
info = l->data;
-
+
if (info->pack == GTK_PACK_END)
- pack_end_cells = g_list_prepend (pack_end_cells, info);
+ pack_end_cells = g_list_prepend (pack_end_cells, info);
}
consecutive_cells = g_list_reverse (consecutive_cells);
@@ -447,9 +453,9 @@ list_consecutive_cells (GtkCellAreaBox *box)
}
static void
-cell_groups_clear (GtkCellAreaBox *box)
+cell_groups_clear (GtkCellAreaBox *box)
{
- GtkCellAreaBoxPrivate *priv = box->priv;
+ GtkCellAreaBoxPrivate *priv = box->priv;
gint i;
for (i = 0; i < priv->groups->len; i++)
@@ -465,7 +471,7 @@ cell_groups_clear (GtkCellAreaBox *box)
static void
cell_groups_rebuild (GtkCellAreaBox *box)
{
- GtkCellAreaBoxPrivate *priv = box->priv;
+ GtkCellAreaBoxPrivate *priv = box->priv;
CellGroup group = { 0, };
CellGroup *group_ptr;
GList *cells, *l;
@@ -488,20 +494,20 @@ cell_groups_rebuild (GtkCellAreaBox *box)
/* A new group starts with any aligned cell, the first group is implied */
if (info->align && l != cells)
- {
- memset (&group, 0x0, sizeof (CellGroup));
- group.id = ++id;
+ {
+ memset (&group, 0x0, sizeof (CellGroup));
+ group.id = ++id;
- g_array_append_val (priv->groups, group);
- group_ptr = &g_array_index (priv->groups, CellGroup, id);
- }
+ g_array_append_val (priv->groups, group);
+ group_ptr = &g_array_index (priv->groups, CellGroup, id);
+ }
group_ptr->cells = g_list_prepend (group_ptr->cells, info);
group_ptr->n_cells++;
/* A group expands if it contains any expand cells */
if (info->expand)
- group_ptr->expand_cells++;
+ group_ptr->expand_cells++;
}
g_list_free (cells);
@@ -518,8 +524,8 @@ cell_groups_rebuild (GtkCellAreaBox *box)
}
static gint
-count_visible_cells (CellGroup *group,
- gint *expand_cells)
+count_visible_cells (CellGroup *group,
+ gint *expand_cells)
{
GList *l;
gint visible_cells = 0;
@@ -530,12 +536,12 @@ count_visible_cells (CellGroup *group,
CellInfo *info = l->data;
if (gtk_cell_renderer_get_visible (info->renderer))
- {
- visible_cells++;
+ {
+ visible_cells++;
- if (info->expand)
- n_expand_cells++;
- }
+ if (info->expand)
+ n_expand_cells++;
+ }
}
if (expand_cells)
@@ -556,15 +562,15 @@ count_expand_groups (GtkCellAreaBox *box)
CellGroup *group = &g_array_index (priv->groups, CellGroup, i);
if (group->expand_cells > 0)
- expand_groups++;
+ expand_groups++;
}
return expand_groups;
}
-static void
+static void
context_weak_notify (GtkCellAreaBox *box,
- GtkCellAreaBoxContext *dead_context)
+ GtkCellAreaBoxContext *dead_context)
{
GtkCellAreaBoxPrivate *priv = box->priv;
@@ -573,7 +579,7 @@ context_weak_notify (GtkCellAreaBox *box,
static void
init_context_group (GtkCellAreaBox *box,
- GtkCellAreaBoxContext *context)
+ GtkCellAreaBoxContext *context)
{
GtkCellAreaBoxPrivate *priv = box->priv;
gint *expand_groups, i;
@@ -598,8 +604,8 @@ init_context_groups (GtkCellAreaBox *box)
GtkCellAreaBoxPrivate *priv = box->priv;
GSList *l;
- /* When the box's groups are reconstructed, contexts need to
- * be reinitialized.
+ /* When the box's groups are reconstructed,
+ * contexts need to be reinitialized.
*/
for (l = priv->contexts; l; l = l->next)
{
@@ -633,9 +639,9 @@ reset_contexts (GtkCellAreaBox *box)
*/
static GSList *
allocate_cells_manually (GtkCellAreaBox *box,
- GtkWidget *widget,
- gint width,
- gint height)
+ GtkWidget *widget,
+ gint width,
+ gint height)
{
GtkCellAreaBoxPrivate *priv = box->priv;
GList *cells, *l;
@@ -650,9 +656,11 @@ allocate_cells_manually (GtkCellAreaBox *box,
if (!priv->cells)
return NULL;
- /* For vertical oriented boxes, we just let the cell renderers realign themselves for rtl */
+ /* For vertical oriented boxes, we just let the cell renderers
+ * realign themselves for rtl
+ */
rtl = (priv->orientation == GTK_ORIENTATION_HORIZONTAL &&
- gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
+ gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
cells = list_consecutive_cells (box);
@@ -689,13 +697,13 @@ allocate_cells_manually (GtkCellAreaBox *box,
CellInfo *info = l->data;
if (!gtk_cell_renderer_get_visible (info->renderer))
- continue;
+ continue;
gtk_cell_area_request_renderer (GTK_CELL_AREA (box), info->renderer,
- priv->orientation,
- widget, for_size,
- &sizes[i].minimum_size,
- &sizes[i].natural_size);
+ priv->orientation,
+ widget, for_size,
+ &sizes[i].minimum_size,
+ &sizes[i].natural_size);
avail_size -= sizes[i].minimum_size;
@@ -727,24 +735,24 @@ allocate_cells_manually (GtkCellAreaBox *box,
AllocatedCell *cell;
if (info->expand)
- {
- sizes[i].minimum_size += extra_size;
- if (extra_extra)
- {
- sizes[i].minimum_size++;
- extra_extra--;
- }
- }
-
+ {
+ sizes[i].minimum_size += extra_size;
+ if (extra_extra)
+ {
+ sizes[i].minimum_size++;
+ extra_extra--;
+ }
+ }
+
if (rtl)
- cell = allocated_cell_new (info->renderer,
- full_size - (position + sizes[i].minimum_size),
- sizes[i].minimum_size);
+ cell = allocated_cell_new (info->renderer,
+ full_size - (position + sizes[i].minimum_size),
+ sizes[i].minimum_size);
else
- cell = allocated_cell_new (info->renderer, position, sizes[i].minimum_size);
+ cell = allocated_cell_new (info->renderer, position, sizes[i].minimum_size);
allocated_cells = g_slist_prepend (allocated_cells, cell);
-
+
position += sizes[i].minimum_size;
position += priv->spacing;
}
@@ -753,7 +761,8 @@ allocate_cells_manually (GtkCellAreaBox *box,
g_list_free (cells);
/* Note it might not be important to reverse the list here at all,
- * we have the correct positions, no need to allocate from left to right */
+ * we have the correct positions, no need to allocate from left to right
+ */
return g_slist_reverse (allocated_cells);
}
@@ -763,10 +772,10 @@ allocate_cells_manually (GtkCellAreaBox *box,
*/
static GSList *
get_allocated_cells (GtkCellAreaBox *box,
- GtkCellAreaBoxContext *context,
- GtkWidget *widget,
- gint width,
- gint height)
+ GtkCellAreaBoxContext *context,
+ GtkWidget *widget,
+ gint width,
+ gint height)
{
GtkCellAreaBoxAllocation *group_allocs;
GtkCellArea *area = GTK_CELL_AREA (box);
@@ -792,131 +801,137 @@ get_allocated_cells (GtkCellAreaBox *box,
for_size = width;
}
- /* For vertical oriented boxes, we just let the cell renderers realign themselves for rtl */
+ /* For vertical oriented boxes, we just let the cell renderers
+ * realign themselves for rtl
+ */
rtl = (priv->orientation == GTK_ORIENTATION_HORIZONTAL &&
- gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
+ gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
for (i = 0; i < n_allocs; i++)
{
- /* We dont always allocate all groups, sometimes the requested group has only invisible
- * cells for every row, hence the usage of group_allocs[i].group_idx here
+ /* We dont always allocate all groups, sometimes the requested
+ * group has only invisible cells for every row, hence the usage
+ * of group_allocs[i].group_idx here
*/
CellGroup *group = &g_array_index (priv->groups, CellGroup, group_allocs[i].group_idx);
/* Exception for single cell groups */
if (group->n_cells == 1)
- {
- CellInfo *info = group->cells->data;
- AllocatedCell *cell;
-
- if (rtl)
- cell = allocated_cell_new (info->renderer,
- full_size - (group_allocs[i].position + group_allocs[i].size),
- group_allocs[i].size);
- else
- cell = allocated_cell_new (info->renderer, group_allocs[i].position, group_allocs[i].size);
-
- allocated_cells = g_slist_prepend (allocated_cells, cell);
- }
+ {
+ CellInfo *info = group->cells->data;
+ AllocatedCell *cell;
+
+ if (rtl)
+ cell = allocated_cell_new (info->renderer,
+ full_size - (group_allocs[i].position + group_allocs[i].size),
+ group_allocs[i].size);
+ else
+ cell = allocated_cell_new (info->renderer, group_allocs[i].position, group_allocs[i].size);
+
+ allocated_cells = g_slist_prepend (allocated_cells, cell);
+ }
else
- {
- GtkRequestedSize *sizes;
- gint avail_size, position;
- gint visible_cells, expand_cells;
- gint extra_size, extra_extra;
+ {
+ GtkRequestedSize *sizes;
+ gint avail_size, position;
+ gint visible_cells, expand_cells;
+ gint extra_size, extra_extra;
- visible_cells = count_visible_cells (group, &expand_cells);
+ visible_cells = count_visible_cells (group, &expand_cells);
- /* If this row has no visible cells in this group, just
- * skip the allocation */
- if (visible_cells == 0)
- continue;
+ /* If this row has no visible cells in this group, just
+ * skip the allocation
+ */
+ if (visible_cells == 0)
+ continue;
- /* Offset the allocation to the group position and allocate into
- * the group's available size */
- position = group_allocs[i].position;
- avail_size = group_allocs[i].size;
+ /* Offset the allocation to the group position
+ * and allocate into the group's available size
+ */
+ position = group_allocs[i].position;
+ avail_size = group_allocs[i].size;
- sizes = g_new (GtkRequestedSize, visible_cells);
+ sizes = g_new (GtkRequestedSize, visible_cells);
- for (j = 0, cell_list = group->cells; cell_list; cell_list = cell_list->next)
- {
- CellInfo *info = cell_list->data;
+ for (j = 0, cell_list = group->cells; cell_list; cell_list = cell_list->next)
+ {
+ CellInfo *info = cell_list->data;
- if (!gtk_cell_renderer_get_visible (info->renderer))
- continue;
+ if (!gtk_cell_renderer_get_visible (info->renderer))
+ continue;
- gtk_cell_area_request_renderer (area, info->renderer,
- priv->orientation,
- widget, for_size,
- &sizes[j].minimum_size,
- &sizes[j].natural_size);
+ gtk_cell_area_request_renderer (area, info->renderer,
+ priv->orientation,
+ widget, for_size,
+ &sizes[j].minimum_size,
+ &sizes[j].natural_size);
- sizes[j].data = info;
- avail_size -= sizes[j].minimum_size;
+ sizes[j].data = info;
+ avail_size -= sizes[j].minimum_size;
- j++;
- }
+ j++;
+ }
- /* Distribute cells naturally within the group */
- avail_size -= (visible_cells - 1) * priv->spacing;
+ /* Distribute cells naturally within the group */
+ avail_size -= (visible_cells - 1) * priv->spacing;
if (avail_size > 0)
avail_size = gtk_distribute_natural_allocation (avail_size, visible_cells, sizes);
else
avail_size = 0;
- /* Calculate/distribute expand for cells */
- if (expand_cells > 0)
- {
- extra_size = avail_size / expand_cells;
- extra_extra = avail_size % expand_cells;
- }
- else
- extra_size = extra_extra = 0;
-
- /* Create the allocated cells (loop only over visible cells here) */
- for (j = 0; j < visible_cells; j++)
- {
- CellInfo *info = sizes[j].data;
- AllocatedCell *cell;
-
- if (info->expand)
- {
- sizes[j].minimum_size += extra_size;
- if (extra_extra)
- {
- sizes[j].minimum_size++;
- extra_extra--;
- }
- }
-
- if (rtl)
- cell = allocated_cell_new (info->renderer,
- full_size - (position + sizes[j].minimum_size),
- sizes[j].minimum_size);
- else
- cell = allocated_cell_new (info->renderer, position, sizes[j].minimum_size);
-
- allocated_cells = g_slist_prepend (allocated_cells, cell);
-
- position += sizes[j].minimum_size;
- position += priv->spacing;
- }
-
- g_free (sizes);
- }
+ /* Calculate/distribute expand for cells */
+ if (expand_cells > 0)
+ {
+ extra_size = avail_size / expand_cells;
+ extra_extra = avail_size % expand_cells;
+ }
+ else
+ extra_size = extra_extra = 0;
+
+ /* Create the allocated cells (loop only over visible cells here) */
+ for (j = 0; j < visible_cells; j++)
+ {
+ CellInfo *info = sizes[j].data;
+ AllocatedCell *cell;
+
+ if (info->expand)
+ {
+ sizes[j].minimum_size += extra_size;
+ if (extra_extra)
+ {
+ sizes[j].minimum_size++;
+ extra_extra--;
+ }
+ }
+
+ if (rtl)
+ cell = allocated_cell_new (info->renderer,
+ full_size - (position + sizes[j].minimum_size),
+ sizes[j].minimum_size);
+ else
+ cell = allocated_cell_new (info->renderer, position, sizes[j].minimum_size);
+
+ allocated_cells = g_slist_prepend (allocated_cells, cell);
+
+ position += sizes[j].minimum_size;
+ position += priv->spacing;
+ }
+
+ g_free (sizes);
+ }
}
/* Note it might not be important to reverse the list here at all,
- * we have the correct positions, no need to allocate from left to right */
+ * we have the correct positions, no need to allocate from left to right
+ */
return g_slist_reverse (allocated_cells);
}
static void
gtk_cell_area_box_focus_changed (GtkCellArea *area,
- GParamSpec *pspec,
- GtkCellAreaBox *box)
+ GParamSpec *pspec,
+ GtkCellAreaBox *box)
{
if (gtk_cell_area_get_focus_cell (area))
box->priv->last_focus_cell = gtk_cell_area_get_focus_cell (area);
@@ -942,7 +957,7 @@ gtk_cell_area_box_finalize (GObject *object)
/* Free the cell grouping info */
cell_groups_clear (box);
g_array_free (priv->groups, TRUE);
-
+
G_OBJECT_CLASS (gtk_cell_area_box_parent_class)->finalize (object);
}
@@ -954,9 +969,9 @@ gtk_cell_area_box_dispose (GObject *object)
static void
gtk_cell_area_box_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec)
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (object);
@@ -979,9 +994,9 @@ gtk_cell_area_box_set_property (GObject *object,
static void
gtk_cell_area_box_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (object);
@@ -1002,17 +1017,17 @@ gtk_cell_area_box_get_property (GObject *object,
/*************************************************************
* GtkCellAreaClass *
*************************************************************/
-static void
+static void
gtk_cell_area_box_add (GtkCellArea *area,
- GtkCellRenderer *renderer)
+ GtkCellRenderer *renderer)
{
gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area),
- renderer, FALSE, TRUE);
+ renderer, FALSE, TRUE);
}
static void
gtk_cell_area_box_remove (GtkCellArea *area,
- GtkCellRenderer *renderer)
+ GtkCellRenderer *renderer)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxPrivate *priv = box->priv;
@@ -1021,8 +1036,8 @@ gtk_cell_area_box_remove (GtkCellArea *area,
if (priv->last_focus_cell == renderer)
priv->last_focus_cell = NULL;
- node = g_list_find_custom (priv->cells, renderer,
- (GCompareFunc)cell_info_find);
+ node = g_list_find_custom (priv->cells, renderer,
+ (GCompareFunc)cell_info_find);
if (node)
{
@@ -1041,8 +1056,8 @@ gtk_cell_area_box_remove (GtkCellArea *area,
static void
gtk_cell_area_box_foreach (GtkCellArea *area,
- GtkCellCallback callback,
- gpointer callback_data)
+ GtkCellCallback callback,
+ gpointer callback_data)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxPrivate *priv = box->priv;
@@ -1053,18 +1068,18 @@ gtk_cell_area_box_foreach (GtkCellArea *area,
CellInfo *info = list->data;
if (callback (info->renderer, callback_data))
- break;
+ break;
}
}
static void
gtk_cell_area_box_foreach_alloc (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- const GdkRectangle *cell_area,
- const GdkRectangle *background_area,
- GtkCellAllocCallback callback,
- gpointer callback_data)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ const GdkRectangle *background_area,
+ GtkCellAllocCallback callback,
+ gpointer callback_data)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxPrivate *priv = box->priv;
@@ -1074,80 +1089,87 @@ gtk_cell_area_box_foreach_alloc (GtkCellArea *area,
gboolean rtl;
rtl = (priv->orientation == GTK_ORIENTATION_HORIZONTAL &&
- gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
+ gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
cell_alloc = *cell_area;
/* Get a list of cells with allocation sizes decided regardless
- * of alignments and pack order etc. */
- allocated_cells = get_allocated_cells (box, box_context, widget,
- cell_area->width, cell_area->height);
+ * of alignments and pack order etc.
+ */
+ allocated_cells = get_allocated_cells (box, box_context, widget,
+ cell_area->width, cell_area->height);
for (l = allocated_cells; l; l = l->next)
{
AllocatedCell *cell = l->data;
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
- {
- cell_alloc.x = cell_area->x + cell->position;
- cell_alloc.width = cell->size;
- }
+ {
+ cell_alloc.x = cell_area->x + cell->position;
+ cell_alloc.width = cell->size;
+ }
else
- {
- cell_alloc.y = cell_area->y + cell->position;
- cell_alloc.height = cell->size;
- }
-
- /* Stop iterating over cells if they flow out of the render area,
- * this can happen because the render area can actually be
- * smaller than the requested area (treeview columns can
+ {
+ cell_alloc.y = cell_area->y + cell->position;
+ cell_alloc.height = cell->size;
+ }
+
+ /* Stop iterating over cells if they flow out of the render
+ * area, this can happen because the render area can actually
+ * be smaller than the requested area (treeview columns can
* be user resizable and can be resized to be smaller than
- * the actual requested area). */
+ * the actual requested area).
+ */
if (cell_alloc.x > cell_area->x + cell_area->width ||
- cell_alloc.x + cell_alloc.width < cell_area->x ||
- cell_alloc.y > cell_area->y + cell_area->height)
- break;
-
- /* Special case for the last cell (or first cell in rtl)... let the last cell consume
- * the remaining space in the area (the last cell is allowed to consume the remaining
- * space if the space given for rendering is actually larger than allocation, this can
- * happen in the expander GtkTreeViewColumn where only the deepest depth column
- * receives the allocation... shallow columns recieve more width). */
+ cell_alloc.x + cell_alloc.width < cell_area->x ||
+ cell_alloc.y > cell_area->y + cell_area->height)
+ break;
+
+ /* Special case for the last cell (or first cell in rtl)...
+ * let the last cell consume the remaining space in the area
+ * (the last cell is allowed to consume the remaining space if
+ * the space given for rendering is actually larger than allocation,
+ * this can happen in the expander GtkTreeViewColumn where only the
+ * deepest depth column receives the allocation... shallow columns
+ * receive more width). */
if (!l->next)
- {
- if (rtl)
- {
- /* Fill the leading space for the first cell in the area (still last in the list) */
- cell_alloc.width = (cell_alloc.x - cell_area->x) + cell_alloc.width;
- cell_alloc.x = cell_area->x;
- }
- else
- {
- cell_alloc.width = cell_area->x + cell_area->width - cell_alloc.x;
- cell_alloc.height = cell_area->y + cell_area->height - cell_alloc.y;
- }
- }
+ {
+ if (rtl)
+ {
+ /* Fill the leading space for the first cell in the area
+ * (still last in the list)
+ */
+ cell_alloc.width = (cell_alloc.x - cell_area->x) + cell_alloc.width;
+ cell_alloc.x = cell_area->x;
+ }
+ else
+ {
+ cell_alloc.width = cell_area->x + cell_area->width - cell_alloc.x;
+ cell_alloc.height = cell_area->y + cell_area->height - cell_alloc.y;
+ }
+ }
else
- {
- /* If the cell we are rendering doesnt fit into the remaining space, clip it
- * so that the underlying renderer has a chance to deal with it (for instance
- * text renderers get a chance to ellipsize).
- */
- if (cell_alloc.x + cell_alloc.width > cell_area->x + cell_area->width)
- cell_alloc.width = cell_area->x + cell_area->width - cell_alloc.x;
-
- if (cell_alloc.y + cell_alloc.height > cell_area->y + cell_area->height)
- cell_alloc.height = cell_area->y + cell_area->height - cell_alloc.y;
- }
+ {
+ /* If the cell we are rendering doesnt fit into the remaining space,
+ * clip it so that the underlying renderer has a chance to deal with
+ * it (for instance text renderers get a chance to ellipsize).
+ */
+ if (cell_alloc.x + cell_alloc.width > cell_area->x + cell_area->width)
+ cell_alloc.width = cell_area->x + cell_area->width - cell_alloc.x;
+
+ if (cell_alloc.y + cell_alloc.height > cell_area->y + cell_area->height)
+ cell_alloc.height = cell_area->y + cell_area->height - cell_alloc.y;
+ }
/* Add portions of the background_area to the cell_alloc
- * to create the cell_background */
+ * to create the cell_background
+ */
cell_background = cell_alloc;
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
- {
- if (l == allocated_cells)
- {
+ {
+ if (l == allocated_cells)
+ {
/* Add the depth to the first cell */
if (rtl)
{
@@ -1159,9 +1181,9 @@ gtk_cell_area_box_foreach_alloc (GtkCellArea *area,
cell_background.width += cell_area->x - background_area->x;
cell_background.x = background_area->x;
}
- }
+ }
- if (l->next == NULL)
+ if (l->next == NULL)
{
/* Grant this cell the remaining space */
int remain = cell_background.x - background_area->x;
@@ -1172,27 +1194,27 @@ gtk_cell_area_box_foreach_alloc (GtkCellArea *area,
cell_background.width = background_area->width - remain;
}
- cell_background.y = background_area->y;
- cell_background.height = background_area->height;
- }
+ cell_background.y = background_area->y;
+ cell_background.height = background_area->height;
+ }
else
- {
- if (l == allocated_cells)
- {
- cell_background.height += cell_background.y - background_area->y;
- cell_background.y = background_area->y;
- }
+ {
+ if (l == allocated_cells)
+ {
+ cell_background.height += cell_background.y - background_area->y;
+ cell_background.y = background_area->y;
+ }
- if (l->next == NULL)
- cell_background.height =
- background_area->height - (cell_background.y - background_area->y);
+ if (l->next == NULL)
+ cell_background.height =
+ background_area->height - (cell_background.y - background_area->y);
- cell_background.x = background_area->x;
- cell_background.width = background_area->width;
- }
+ cell_background.x = background_area->x;
+ cell_background.width = background_area->width;
+ }
if (callback (cell->renderer, &cell_alloc, &cell_background, callback_data))
- break;
+ break;
}
g_slist_foreach (allocated_cells, (GFunc)allocated_cell_free, NULL);
@@ -1201,12 +1223,12 @@ gtk_cell_area_box_foreach_alloc (GtkCellArea *area,
static void
gtk_cell_area_box_set_cell_property (GtkCellArea *area,
- GtkCellRenderer *renderer,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec)
+ GtkCellRenderer *renderer,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
- GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
+ GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxPrivate *priv = box->priv;
GList *node;
CellInfo *info;
@@ -1214,8 +1236,8 @@ gtk_cell_area_box_set_cell_property (GtkCellArea *area,
gboolean val;
GtkPackType pack_type;
- node = g_list_find_custom (priv->cells, renderer,
- (GCompareFunc)cell_info_find);
+ node = g_list_find_custom (priv->cells, renderer,
+ (GCompareFunc)cell_info_find);
if (!node)
return;
@@ -1227,30 +1249,30 @@ gtk_cell_area_box_set_cell_property (GtkCellArea *area,
val = g_value_get_boolean (value);
if (info->expand != val)
- {
- info->expand = val;
- rebuild = TRUE;
- }
+ {
+ info->expand = val;
+ rebuild = TRUE;
+ }
break;
case CELL_PROP_ALIGN:
val = g_value_get_boolean (value);
if (info->align != val)
- {
- info->align = val;
- rebuild = TRUE;
- }
+ {
+ info->align = val;
+ rebuild = TRUE;
+ }
break;
case CELL_PROP_PACK_TYPE:
pack_type = g_value_get_enum (value);
if (info->pack != pack_type)
- {
- info->pack = pack_type;
- rebuild = TRUE;
- }
+ {
+ info->pack = pack_type;
+ rebuild = TRUE;
+ }
break;
default:
GTK_CELL_AREA_WARN_INVALID_CELL_PROPERTY_ID (area, prop_id, pspec);
@@ -1264,18 +1286,18 @@ gtk_cell_area_box_set_cell_property (GtkCellArea *area,
static void
gtk_cell_area_box_get_cell_property (GtkCellArea *area,
- GtkCellRenderer *renderer,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
+ GtkCellRenderer *renderer,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
- GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
+ GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxPrivate *priv = box->priv;
GList *node;
CellInfo *info;
- node = g_list_find_custom (priv->cells, renderer,
- (GCompareFunc)cell_info_find);
+ node = g_list_find_custom (priv->cells, renderer,
+ (GCompareFunc)cell_info_find);
if (!node)
return;
@@ -1307,8 +1329,8 @@ gtk_cell_area_box_create_context (GtkCellArea *area)
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxPrivate *priv = box->priv;
GtkCellAreaContext *context =
- (GtkCellAreaContext *)g_object_new (GTK_TYPE_CELL_AREA_BOX_CONTEXT,
- "area", area, NULL);
+ (GtkCellAreaContext *)g_object_new (GTK_TYPE_CELL_AREA_BOX_CONTEXT,
+ "area", area, NULL);
priv->contexts = g_slist_prepend (priv->contexts, context);
@@ -1322,13 +1344,13 @@ gtk_cell_area_box_create_context (GtkCellArea *area)
static GtkCellAreaContext *
gtk_cell_area_box_copy_context (GtkCellArea *area,
- GtkCellAreaContext *context)
+ GtkCellAreaContext *context)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxPrivate *priv = box->priv;
- GtkCellAreaContext *copy =
- (GtkCellAreaContext *)gtk_cell_area_box_context_copy (GTK_CELL_AREA_BOX (area),
- GTK_CELL_AREA_BOX_CONTEXT (context));
+ GtkCellAreaContext *copy =
+ (GtkCellAreaContext *)gtk_cell_area_box_context_copy (GTK_CELL_AREA_BOX (area),
+ GTK_CELL_AREA_BOX_CONTEXT (context));
priv->contexts = g_slist_prepend (priv->contexts, copy);
@@ -1337,7 +1359,7 @@ gtk_cell_area_box_copy_context (GtkCellArea *area,
return copy;
}
-static GtkSizeRequestMode
+static GtkSizeRequestMode
gtk_cell_area_box_get_request_mode (GtkCellArea *area)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
@@ -1350,12 +1372,12 @@ gtk_cell_area_box_get_request_mode (GtkCellArea *area)
static void
compute_size (GtkCellAreaBox *box,
- GtkOrientation orientation,
- GtkCellAreaBoxContext *context,
- GtkWidget *widget,
- gint for_size,
- gint *minimum_size,
- gint *natural_size)
+ GtkOrientation orientation,
+ GtkCellAreaBoxContext *context,
+ GtkWidget *widget,
+ gint for_size,
+ gint *minimum_size,
+ gint *natural_size)
{
GtkCellAreaBoxPrivate *priv = box->priv;
GtkCellArea *area = GTK_CELL_AREA (box);
@@ -1363,7 +1385,7 @@ compute_size (GtkCellAreaBox *box,
gint i;
gint min_size = 0;
gint nat_size = 0;
-
+
for (i = 0; i < priv->groups->len; i++)
{
CellGroup *group = &g_array_index (priv->groups, CellGroup, i);
@@ -1371,60 +1393,60 @@ compute_size (GtkCellAreaBox *box,
gint group_nat_size = 0;
for (list = group->cells; list; list = list->next)
- {
- CellInfo *info = list->data;
- gint renderer_min_size, renderer_nat_size;
-
- if (!gtk_cell_renderer_get_visible (info->renderer))
- continue;
-
- gtk_cell_area_request_renderer (area, info->renderer, orientation, widget, for_size,
- &renderer_min_size, &renderer_nat_size);
-
- if (orientation == priv->orientation)
- {
- if (min_size > 0)
- {
- min_size += priv->spacing;
- nat_size += priv->spacing;
- }
-
- if (group_min_size > 0)
- {
- group_min_size += priv->spacing;
- group_nat_size += priv->spacing;
- }
-
- min_size += renderer_min_size;
- nat_size += renderer_nat_size;
- group_min_size += renderer_min_size;
- group_nat_size += renderer_nat_size;
- }
- else
- {
- min_size = MAX (min_size, renderer_min_size);
- nat_size = MAX (nat_size, renderer_nat_size);
- group_min_size = MAX (group_min_size, renderer_min_size);
- group_nat_size = MAX (group_nat_size, renderer_nat_size);
- }
- }
+ {
+ CellInfo *info = list->data;
+ gint renderer_min_size, renderer_nat_size;
+
+ if (!gtk_cell_renderer_get_visible (info->renderer))
+ continue;
+
+ gtk_cell_area_request_renderer (area, info->renderer, orientation, widget, for_size,
+ &renderer_min_size, &renderer_nat_size);
+
+ if (orientation == priv->orientation)
+ {
+ if (min_size > 0)
+ {
+ min_size += priv->spacing;
+ nat_size += priv->spacing;
+ }
+
+ if (group_min_size > 0)
+ {
+ group_min_size += priv->spacing;
+ group_nat_size += priv->spacing;
+ }
+
+ min_size += renderer_min_size;
+ nat_size += renderer_nat_size;
+ group_min_size += renderer_min_size;
+ group_nat_size += renderer_nat_size;
+ }
+ else
+ {
+ min_size = MAX (min_size, renderer_min_size);
+ nat_size = MAX (nat_size, renderer_nat_size);
+ group_min_size = MAX (group_min_size, renderer_min_size);
+ group_nat_size = MAX (group_nat_size, renderer_nat_size);
+ }
+ }
if (orientation == GTK_ORIENTATION_HORIZONTAL)
- {
- if (for_size < 0)
- gtk_cell_area_box_context_push_group_width (context, group->id, group_min_size, group_nat_size);
- else
- gtk_cell_area_box_context_push_group_width_for_height (context, group->id, for_size,
- group_min_size, group_nat_size);
- }
+ {
+ if (for_size < 0)
+ gtk_cell_area_box_context_push_group_width (context, group->id, group_min_size, group_nat_size);
+ else
+ gtk_cell_area_box_context_push_group_width_for_height (context, group->id, for_size,
+ group_min_size, group_nat_size);
+ }
else
- {
- if (for_size < 0)
- gtk_cell_area_box_context_push_group_height (context, group->id, group_min_size, group_nat_size);
- else
- gtk_cell_area_box_context_push_group_height_for_width (context, group->id, for_size,
- group_min_size, group_nat_size);
- }
+ {
+ if (for_size < 0)
+ gtk_cell_area_box_context_push_group_height (context, group->id, group_min_size, group_nat_size);
+ else
+ gtk_cell_area_box_context_push_group_height_for_width (context, group->id, for_size,
+ group_min_size, group_nat_size);
+ }
}
*minimum_size = min_size;
@@ -1432,15 +1454,15 @@ compute_size (GtkCellAreaBox *box,
/* Update rtl state for focus navigation to work */
priv->rtl = (priv->orientation == GTK_ORIENTATION_HORIZONTAL &&
- gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
+ gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
}
GtkRequestedSize *
get_group_sizes (GtkCellArea *area,
- CellGroup *group,
- GtkOrientation orientation,
- GtkWidget *widget,
- gint *n_sizes)
+ CellGroup *group,
+ GtkOrientation orientation,
+ GtkWidget *widget,
+ gint *n_sizes)
{
GtkRequestedSize *sizes;
GList *l;
@@ -1454,14 +1476,14 @@ get_group_sizes (GtkCellArea *area,
CellInfo *info = l->data;
if (!gtk_cell_renderer_get_visible (info->renderer))
- continue;
+ continue;
sizes[i].data = info;
-
+
gtk_cell_area_request_renderer (area, info->renderer,
- orientation, widget, -1,
- &sizes[i].minimum_size,
- &sizes[i].natural_size);
+ orientation, widget, -1,
+ &sizes[i].minimum_size,
+ &sizes[i].natural_size);
i++;
}
@@ -1471,11 +1493,11 @@ get_group_sizes (GtkCellArea *area,
static void
compute_group_size_for_opposing_orientation (GtkCellAreaBox *box,
- CellGroup *group,
- GtkWidget *widget,
- gint for_size,
- gint *minimum_size,
- gint *natural_size)
+ CellGroup *group,
+ GtkWidget *widget,
+ gint for_size,
+ gint *minimum_size,
+ gint *natural_size)
{
GtkCellAreaBoxPrivate *priv = box->priv;
GtkCellArea *area = GTK_CELL_AREA (box);
@@ -1486,8 +1508,8 @@ compute_group_size_for_opposing_orientation (GtkCellAreaBox *box,
CellInfo *info = group->cells->data;
gtk_cell_area_request_renderer (area, info->renderer,
- OPPOSITE_ORIENTATION (priv->orientation),
- widget, for_size, minimum_size, natural_size);
+ OPPOSITE_ORIENTATION (priv->orientation),
+ widget, for_size, minimum_size, natural_size);
}
else
{
@@ -1503,7 +1525,7 @@ compute_group_size_for_opposing_orientation (GtkCellAreaBox *box,
/* First naturally allocate the cells in the group into the for_size */
avail_size -= (n_sizes - 1) * priv->spacing;
for (i = 0; i < n_sizes; i++)
- avail_size -= orientation_sizes[i].minimum_size;
+ avail_size -= orientation_sizes[i].minimum_size;
if (avail_size > 0)
avail_size = gtk_distribute_natural_allocation (avail_size, n_sizes, orientation_sizes);
@@ -1512,38 +1534,38 @@ compute_group_size_for_opposing_orientation (GtkCellAreaBox *box,
/* Calculate/distribute expand for cells */
if (group->expand_cells > 0)
- {
- extra_size = avail_size / group->expand_cells;
- extra_extra = avail_size % group->expand_cells;
- }
+ {
+ extra_size = avail_size / group->expand_cells;
+ extra_extra = avail_size % group->expand_cells;
+ }
else
- extra_size = extra_extra = 0;
+ extra_size = extra_extra = 0;
for (i = 0; i < n_sizes; i++)
- {
- gint cell_min, cell_nat;
-
- info = orientation_sizes[i].data;
-
- if (info->expand)
- {
- orientation_sizes[i].minimum_size += extra_size;
- if (extra_extra)
- {
- orientation_sizes[i].minimum_size++;
- extra_extra--;
- }
- }
-
- gtk_cell_area_request_renderer (area, info->renderer,
- OPPOSITE_ORIENTATION (priv->orientation),
- widget,
- orientation_sizes[i].minimum_size,
- &cell_min, &cell_nat);
-
- min_size = MAX (min_size, cell_min);
- nat_size = MAX (nat_size, cell_nat);
- }
+ {
+ gint cell_min, cell_nat;
+
+ info = orientation_sizes[i].data;
+
+ if (info->expand)
+ {
+ orientation_sizes[i].minimum_size += extra_size;
+ if (extra_extra)
+ {
+ orientation_sizes[i].minimum_size++;
+ extra_extra--;
+ }
+ }
+
+ gtk_cell_area_request_renderer (area, info->renderer,
+ OPPOSITE_ORIENTATION (priv->orientation),
+ widget,
+ orientation_sizes[i].minimum_size,
+ &cell_min, &cell_nat);
+
+ min_size = MAX (min_size, cell_min);
+ nat_size = MAX (nat_size, cell_nat);
+ }
*minimum_size = min_size;
*natural_size = nat_size;
@@ -1553,12 +1575,12 @@ compute_group_size_for_opposing_orientation (GtkCellAreaBox *box,
}
static void
-compute_size_for_opposing_orientation (GtkCellAreaBox *box,
- GtkCellAreaBoxContext *context,
- GtkWidget *widget,
- gint for_size,
- gint *minimum_size,
- gint *natural_size)
+compute_size_for_opposing_orientation (GtkCellAreaBox *box,
+ GtkCellAreaBoxContext *context,
+ GtkWidget *widget,
+ gint for_size,
+ gint *minimum_size,
+ gint *natural_size)
{
GtkCellAreaBoxPrivate *priv = box->priv;
CellGroup *group;
@@ -1595,44 +1617,46 @@ compute_size_for_opposing_orientation (GtkCellAreaBox *box,
extra_size = extra_extra = 0;
/* Now we need to naturally allocate sizes for cells in each group
- * and push the height-for-width for each group accordingly while accumulating
- * the overall height-for-width for this row.
+ * and push the height-for-width for each group accordingly while
+ * accumulating the overall height-for-width for this row.
*/
for (i = 0; i < n_groups; i++)
{
gint group_min, group_nat;
gint group_idx = GPOINTER_TO_INT (orientation_sizes[i].data);
-
+
group = &g_array_index (priv->groups, CellGroup, group_idx);
if (group->expand_cells > 0)
- {
- orientation_sizes[i].minimum_size += extra_size;
- if (extra_extra)
- {
- orientation_sizes[i].minimum_size++;
- extra_extra--;
- }
- }
-
- /* Now we have the allocation for the group, request it's height-for-width */
+ {
+ orientation_sizes[i].minimum_size += extra_size;
+ if (extra_extra)
+ {
+ orientation_sizes[i].minimum_size++;
+ extra_extra--;
+ }
+ }
+
+ /* Now we have the allocation for the group,
+ * request it's height-for-width
+ */
compute_group_size_for_opposing_orientation (box, group, widget,
- orientation_sizes[i].minimum_size,
- &group_min, &group_nat);
+ orientation_sizes[i].minimum_size,
+ &group_min, &group_nat);
min_size = MAX (min_size, group_min);
nat_size = MAX (nat_size, group_nat);
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
- {
- gtk_cell_area_box_context_push_group_height_for_width (context, group_idx, for_size,
- group_min, group_nat);
- }
+ {
+ gtk_cell_area_box_context_push_group_height_for_width (context, group_idx, for_size,
+ group_min, group_nat);
+ }
else
- {
- gtk_cell_area_box_context_push_group_width_for_height (context, group_idx, for_size,
- group_min, group_nat);
- }
+ {
+ gtk_cell_area_box_context_push_group_width_for_height (context, group_idx, for_size,
+ group_min, group_nat);
+ }
}
*minimum_size = min_size;
@@ -1642,17 +1666,17 @@ compute_size_for_opposing_orientation (GtkCellAreaBox *box,
/* Update rtl state for focus navigation to work */
priv->rtl = (priv->orientation == GTK_ORIENTATION_HORIZONTAL &&
- gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
+ gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
}
static void
gtk_cell_area_box_get_preferred_width (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint *minimum_width,
- gint *natural_width)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint *minimum_width,
+ gint *natural_width)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxContext *box_context;
@@ -1662,10 +1686,11 @@ gtk_cell_area_box_get_preferred_width (GtkCellArea *area,
box_context = GTK_CELL_AREA_BOX_CONTEXT (context);
- /* Compute the size of all renderers for current row data,
- * bumping cell alignments in the context along the way */
+ /* Compute the size of all renderers for current row data,
+ * bumping cell alignments in the context along the way
+ */
compute_size (box, GTK_ORIENTATION_HORIZONTAL,
- box_context, widget, -1, &min_width, &nat_width);
+ box_context, widget, -1, &min_width, &nat_width);
if (minimum_width)
*minimum_width = min_width;
@@ -1676,10 +1701,10 @@ gtk_cell_area_box_get_preferred_width (GtkCellArea *area,
static void
gtk_cell_area_box_get_preferred_height (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint *minimum_height,
- gint *natural_height)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint *minimum_height,
+ gint *natural_height)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxContext *box_context;
@@ -1689,10 +1714,11 @@ gtk_cell_area_box_get_preferred_height (GtkCellArea *area,
box_context = GTK_CELL_AREA_BOX_CONTEXT (context);
- /* Compute the size of all renderers for current row data,
- * bumping cell alignments in the context along the way */
+ /* Compute the size of all renderers for current row data,
+ * bumping cell alignments in the context along the way
+ */
compute_size (box, GTK_ORIENTATION_VERTICAL,
- box_context, widget, -1, &min_height, &nat_height);
+ box_context, widget, -1, &min_height, &nat_height);
if (minimum_height)
*minimum_height = min_height;
@@ -1703,11 +1729,11 @@ gtk_cell_area_box_get_preferred_height (GtkCellArea *area,
static void
gtk_cell_area_box_get_preferred_height_for_width (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint width,
+ gint *minimum_height,
+ gint *natural_height)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxContext *box_context;
@@ -1721,14 +1747,17 @@ gtk_cell_area_box_get_preferred_height_for_width (GtkCellArea *area,
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
{
- /* Add up vertical requests of height for width and push the overall
- * cached sizes for alignments */
+ /* Add up vertical requests of height for width and push
+ * the overall cached sizes for alignments
+ */
compute_size (box, priv->orientation, box_context, widget, width, &min_height, &nat_height);
}
else
{
- /* Juice: virtually allocate cells into the for_width using the
- * alignments and then return the overall height for that width, and cache it */
+ /* Juice: virtually allocate cells into the for_width using the
+ * alignments and then return the overall height for that width,
+ * and cache it
+ */
compute_size_for_opposing_orientation (box, box_context, widget, width, &min_height, &nat_height);
}
@@ -1741,11 +1770,11 @@ gtk_cell_area_box_get_preferred_height_for_width (GtkCellArea *area,
static void
gtk_cell_area_box_get_preferred_width_for_height (GtkCellArea *area,
- GtkCellAreaContext *context,
- GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width)
+ GtkCellAreaContext *context,
+ GtkWidget *widget,
+ gint height,
+ gint *minimum_width,
+ gint *natural_width)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxContext *box_context;
@@ -1759,14 +1788,17 @@ gtk_cell_area_box_get_preferred_width_for_height (GtkCellArea *area,
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
- /* Add up horizontal requests of width for height and push the overall
- * cached sizes for alignments */
+ /* Add up horizontal requests of width for height and push
+ * the overall cached sizes for alignments
+ */
compute_size (box, priv->orientation, box_context, widget, height, &min_width, &nat_width);
}
else
{
- /* Juice: horizontally allocate cells into the for_height using the
- * alignments and then return the overall width for that height, and cache it */
+ /* Juice: horizontally allocate cells into the for_height using the
+ * alignments and then return the overall width for that height,
+ * and cache it
+ */
compute_size_for_opposing_orientation (box, box_context, widget, height, &min_width, &nat_width);
}
@@ -1786,7 +1818,7 @@ enum {
static gboolean
gtk_cell_area_box_focus (GtkCellArea *area,
- GtkDirectionType direction)
+ GtkDirectionType direction)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxPrivate *priv = box->priv;
@@ -1814,29 +1846,29 @@ gtk_cell_area_box_focus (GtkCellArea *area,
case GTK_DIR_TAB_BACKWARD:
cycle = priv->rtl ? FOCUS_NEXT : FOCUS_PREV;
break;
- case GTK_DIR_UP:
+ case GTK_DIR_UP:
if (priv->orientation == GTK_ORIENTATION_VERTICAL || !priv->last_focus_cell)
- cycle = FOCUS_PREV;
+ cycle = FOCUS_PREV;
else if (!focus_cell)
- cycle = FOCUS_LAST_CELL;
+ cycle = FOCUS_LAST_CELL;
break;
case GTK_DIR_DOWN:
if (priv->orientation == GTK_ORIENTATION_VERTICAL || !priv->last_focus_cell)
- cycle = FOCUS_NEXT;
+ cycle = FOCUS_NEXT;
else if (!focus_cell)
- cycle = FOCUS_LAST_CELL;
+ cycle = FOCUS_LAST_CELL;
break;
case GTK_DIR_LEFT:
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL || !priv->last_focus_cell)
- cycle = priv->rtl ? FOCUS_NEXT : FOCUS_PREV;
+ cycle = priv->rtl ? FOCUS_NEXT : FOCUS_PREV;
else if (!focus_cell)
- cycle = FOCUS_LAST_CELL;
+ cycle = FOCUS_LAST_CELL;
break;
case GTK_DIR_RIGHT:
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL || !priv->last_focus_cell)
- cycle = priv->rtl ? FOCUS_PREV : FOCUS_NEXT;
+ cycle = priv->rtl ? FOCUS_PREV : FOCUS_NEXT;
else if (!focus_cell)
- cycle = FOCUS_LAST_CELL;
+ cycle = FOCUS_LAST_CELL;
break;
default:
break;
@@ -1853,31 +1885,31 @@ gtk_cell_area_box_focus (GtkCellArea *area,
GList *list;
gint i;
- /* If there is no focused cell, focus on the first (or last) one in the list */
+ /* If there is no focused cell, focus on the first (or last) one */
if (!focus_cell)
- found_cell = TRUE;
-
- for (i = (cycle == FOCUS_NEXT) ? 0 : priv->groups->len -1;
- cycled_focus == FALSE && i >= 0 && i < priv->groups->len;
- i = (cycle == FOCUS_NEXT) ? i + 1 : i - 1)
- {
- CellGroup *group = &g_array_index (priv->groups, CellGroup, i);
-
- for (list = (cycle == FOCUS_NEXT) ? g_list_first (group->cells) : g_list_last (group->cells);
- cycled_focus == FALSE && list; list = (cycle == FOCUS_NEXT) ? list->next : list->prev)
- {
- CellInfo *info = list->data;
-
- if (info->renderer == focus_cell)
- found_cell = TRUE;
- else if (found_cell && /* Dont give focus to cells that are siblings to a focus cell */
- gtk_cell_area_get_focus_from_sibling (area, info->renderer) == NULL)
- {
+ found_cell = TRUE;
+
+ for (i = (cycle == FOCUS_NEXT) ? 0 : priv->groups->len -1;
+ cycled_focus == FALSE && i >= 0 && i < priv->groups->len;
+ i = (cycle == FOCUS_NEXT) ? i + 1 : i - 1)
+ {
+ CellGroup *group = &g_array_index (priv->groups, CellGroup, i);
+
+ for (list = (cycle == FOCUS_NEXT) ? g_list_first (group->cells) : g_list_last (group->cells);
+ cycled_focus == FALSE && list; list = (cycle == FOCUS_NEXT) ? list->next : list->prev)
+ {
+ CellInfo *info = list->data;
+
+ if (info->renderer == focus_cell)
+ found_cell = TRUE;
+ else if (found_cell && /* Dont give focus to cells that are siblings to a focus cell */
+ gtk_cell_area_get_focus_from_sibling (area, info->renderer) == NULL)
+ {
gtk_cell_area_set_focus_cell (area, info->renderer);
cycled_focus = TRUE;
- }
- }
- }
+ }
+ }
+ }
}
if (!cycled_focus)
@@ -1900,32 +1932,32 @@ gtk_cell_area_box_cell_layout_init (GtkCellLayoutIface *iface)
static void
gtk_cell_area_box_layout_pack_start (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer,
- gboolean expand)
+ GtkCellRenderer *renderer,
+ gboolean expand)
{
gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (cell_layout), renderer, expand, TRUE);
}
static void
gtk_cell_area_box_layout_pack_end (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer,
- gboolean expand)
+ GtkCellRenderer *renderer,
+ gboolean expand)
{
gtk_cell_area_box_pack_end (GTK_CELL_AREA_BOX (cell_layout), renderer, expand, TRUE);
}
static void
gtk_cell_area_box_layout_reorder (GtkCellLayout *cell_layout,
- GtkCellRenderer *renderer,
- gint position)
+ GtkCellRenderer *renderer,
+ gint position)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (cell_layout);
GtkCellAreaBoxPrivate *priv = box->priv;
GList *node;
CellInfo *info;
-
- node = g_list_find_custom (priv->cells, renderer,
- (GCompareFunc)cell_info_find);
+
+ node = g_list_find_custom (priv->cells, renderer,
+ (GCompareFunc)cell_info_find);
if (node)
{
@@ -1943,10 +1975,12 @@ gtk_cell_area_box_layout_reorder (GtkCellLayout *cell_layout,
*************************************************************/
/**
* gtk_cell_area_box_new:
- *
+ *
* Creates a new #GtkCellAreaBox.
*
* Return value: a newly created #GtkCellAreaBox
+ *
+ * Since: 3.0
*/
GtkCellArea *
gtk_cell_area_box_new (void)
@@ -1960,20 +1994,20 @@ gtk_cell_area_box_new (void)
* @renderer: the #GtkCellRenderer to add
* @expand: whether @renderer should receive extra space when the area receives
* more than its natural size
- * @align: whether @renderer should be aligned in adjacent rows.
+ * @align: whether @renderer should be aligned in adjacent rows
*
* Adds @renderer to @box, packed with reference to the start of @box.
*
- * The @renderer is packed after any other #GtkCellRenderer packed with reference
- * to the start of @box.
+ * The @renderer is packed after any other #GtkCellRenderer packed
+ * with reference to the start of @box.
*
* Since: 3.0
*/
void
gtk_cell_area_box_pack_start (GtkCellAreaBox *box,
- GtkCellRenderer *renderer,
- gboolean expand,
- gboolean align)
+ GtkCellRenderer *renderer,
+ gboolean expand,
+ gboolean align)
{
GtkCellAreaBoxPrivate *priv;
CellInfo *info;
@@ -1983,8 +2017,8 @@ gtk_cell_area_box_pack_start (GtkCellAreaBox *box,
priv = box->priv;
- if (g_list_find_custom (priv->cells, renderer,
- (GCompareFunc)cell_info_find))
+ if (g_list_find_custom (priv->cells, renderer,
+ (GCompareFunc)cell_info_find))
{
g_warning ("Refusing to add the same cell renderer to a GtkCellAreaBox twice");
return;
@@ -2003,20 +2037,20 @@ gtk_cell_area_box_pack_start (GtkCellAreaBox *box,
* @renderer: the #GtkCellRenderer to add
* @expand: whether @renderer should receive extra space when the area receives
* more than its natural size
- * @align: whether @renderer should be aligned in adjacent rows.
+ * @align: whether @renderer should be aligned in adjacent rows
*
* Adds @renderer to @box, packed with reference to the end of @box.
*
- * The @renderer is packed after (away from end of) any other #GtkCellRenderer
- * packed with reference to the end of @box.
+ * The @renderer is packed after (away from end of) any other
+ * #GtkCellRenderer packed with reference to the end of @box.
*
* Since: 3.0
*/
void
gtk_cell_area_box_pack_end (GtkCellAreaBox *box,
- GtkCellRenderer *renderer,
- gboolean expand,
- gboolean align)
+ GtkCellRenderer *renderer,
+ gboolean expand,
+ gboolean align)
{
GtkCellAreaBoxPrivate *priv;
CellInfo *info;
@@ -2026,8 +2060,8 @@ gtk_cell_area_box_pack_end (GtkCellAreaBox *box,
priv = box->priv;
- if (g_list_find_custom (priv->cells, renderer,
- (GCompareFunc)cell_info_find))
+ if (g_list_find_custom (priv->cells, renderer,
+ (GCompareFunc)cell_info_find))
{
g_warning ("Refusing to add the same cell renderer to a GtkCellArea twice");
return;
@@ -2069,7 +2103,7 @@ gtk_cell_area_box_get_spacing (GtkCellAreaBox *box)
*/
void
gtk_cell_area_box_set_spacing (GtkCellAreaBox *box,
- gint spacing)
+ gint spacing)
{
GtkCellAreaBoxPrivate *priv;
diff --git a/gtk/gtkcellareabox.h b/gtk/gtkcellareabox.h
index a6d3a06..632ea93 100644
--- a/gtk/gtkcellareabox.h
+++ b/gtk/gtkcellareabox.h
@@ -32,10 +32,10 @@
G_BEGIN_DECLS
-#define GTK_TYPE_CELL_AREA_BOX (gtk_cell_area_box_get_type ())
-#define GTK_CELL_AREA_BOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_AREA_BOX, GtkCellAreaBox))
-#define GTK_CELL_AREA_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_AREA_BOX, GtkCellAreaBoxClass))
-#define GTK_IS_CELL_AREA_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_AREA_BOX))
+#define GTK_TYPE_CELL_AREA_BOX (gtk_cell_area_box_get_type ())
+#define GTK_CELL_AREA_BOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_AREA_BOX, GtkCellAreaBox))
+#define GTK_CELL_AREA_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_AREA_BOX, GtkCellAreaBoxClass))
+#define GTK_IS_CELL_AREA_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_AREA_BOX))
#define GTK_IS_CELL_AREA_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_AREA_BOX))
#define GTK_CELL_AREA_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_AREA_BOX, GtkCellAreaBoxClass))
@@ -63,20 +63,20 @@ struct _GtkCellAreaBoxClass
void (*_gtk_reserved4) (void);
};
-GType gtk_cell_area_box_get_type (void) G_GNUC_CONST;
+GType gtk_cell_area_box_get_type (void) G_GNUC_CONST;
-GtkCellArea *gtk_cell_area_box_new (void);
-void gtk_cell_area_box_pack_start (GtkCellAreaBox *box,
- GtkCellRenderer *renderer,
- gboolean expand,
- gboolean align);
-void gtk_cell_area_box_pack_end (GtkCellAreaBox *box,
- GtkCellRenderer *renderer,
- gboolean expand,
- gboolean align);
-gint gtk_cell_area_box_get_spacing (GtkCellAreaBox *box);
-void gtk_cell_area_box_set_spacing (GtkCellAreaBox *box,
- gint spacing);
+GtkCellArea *gtk_cell_area_box_new (void);
+void gtk_cell_area_box_pack_start (GtkCellAreaBox *box,
+ GtkCellRenderer *renderer,
+ gboolean expand,
+ gboolean align);
+void gtk_cell_area_box_pack_end (GtkCellAreaBox *box,
+ GtkCellRenderer *renderer,
+ gboolean expand,
+ gboolean align);
+gint gtk_cell_area_box_get_spacing (GtkCellAreaBox *box);
+void gtk_cell_area_box_set_spacing (GtkCellAreaBox *box,
+ gint spacing);
G_END_DECLS
diff --git a/gtk/gtkcellareaboxcontext.c b/gtk/gtkcellareaboxcontext.c
index 2c0fa22..b68002d 100644
--- a/gtk/gtkcellareaboxcontext.c
+++ b/gtk/gtkcellareaboxcontext.c
@@ -33,32 +33,32 @@ static void gtk_cell_area_box_context_finalize (GObject
/* GtkCellAreaContextClass */
static void gtk_cell_area_box_context_reset (GtkCellAreaContext *context);
static void gtk_cell_area_box_context_allocate (GtkCellAreaContext *context,
- gint width,
- gint height);
+ gint width,
+ gint height);
static void gtk_cell_area_box_context_get_preferred_height_for_width (GtkCellAreaContext *context,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ gint width,
+ gint *minimum_height,
+ gint *natural_height);
static void gtk_cell_area_box_context_get_preferred_width_for_height (GtkCellAreaContext *context,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ gint height,
+ gint *minimum_width,
+ gint *natural_width);
/* Internal functions */
static void gtk_cell_area_box_context_sum (GtkCellAreaBoxContext *context,
- GtkOrientation orientation,
- gint for_size,
- gint *minimum_size,
- gint *natural_size);
+ GtkOrientation orientation,
+ gint for_size,
+ gint *minimum_size,
+ gint *natural_size);
static void free_cache_array (GArray *array);
static GArray *group_array_new (GtkCellAreaBoxContext *context);
static GArray *get_array (GtkCellAreaBoxContext *context,
- GtkOrientation orientation,
- gint for_size);
+ GtkOrientation orientation,
+ gint for_size);
static gboolean group_expands (GtkCellAreaBoxContext *context,
- gint group_idx);
+ gint group_idx);
static gint count_expand_groups (GtkCellAreaBoxContext *context);
@@ -110,8 +110,8 @@ group_array_new (GtkCellAreaBoxContext *context)
static GArray *
get_array (GtkCellAreaBoxContext *context,
- GtkOrientation orientation,
- gint for_size)
+ GtkOrientation orientation,
+ gint for_size)
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
GArray *array;
@@ -119,26 +119,26 @@ get_array (GtkCellAreaBoxContext *context,
if (for_size < 0)
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
- array = priv->base_widths;
+ array = priv->base_widths;
else
- array = priv->base_heights;
+ array = priv->base_heights;
}
else
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
- {
- array = g_hash_table_lookup (priv->widths, GINT_TO_POINTER (for_size));
+ {
+ array = g_hash_table_lookup (priv->widths, GINT_TO_POINTER (for_size));
- if (!array)
- array = priv->base_widths;
- }
+ if (!array)
+ array = priv->base_widths;
+ }
else
- {
- array = g_hash_table_lookup (priv->heights, GINT_TO_POINTER (for_size));
+ {
+ array = g_hash_table_lookup (priv->heights, GINT_TO_POINTER (for_size));
- if (!array)
- array = priv->base_heights;
- }
+ if (!array)
+ array = priv->base_heights;
+ }
}
return array;
@@ -146,7 +146,7 @@ get_array (GtkCellAreaBoxContext *context,
static gboolean
group_expands (GtkCellAreaBoxContext *context,
- gint group_idx)
+ gint group_idx)
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
@@ -164,7 +164,7 @@ count_expand_groups (GtkCellAreaBoxContext *context)
for (i = 0; i < priv->base_widths->len; i++)
{
if (priv->expand[i])
- expand++;
+ expand++;
}
return expand;
@@ -176,17 +176,17 @@ gtk_cell_area_box_context_init (GtkCellAreaBoxContext *box_context)
GtkCellAreaBoxContextPrivate *priv;
box_context->priv = G_TYPE_INSTANCE_GET_PRIVATE (box_context,
- GTK_TYPE_CELL_AREA_BOX_CONTEXT,
- GtkCellAreaBoxContextPrivate);
+ GTK_TYPE_CELL_AREA_BOX_CONTEXT,
+ GtkCellAreaBoxContextPrivate);
priv = box_context->priv;
priv->base_widths = g_array_new (FALSE, TRUE, sizeof (CachedSize));
priv->base_heights = g_array_new (FALSE, TRUE, sizeof (CachedSize));
priv->widths = g_hash_table_new_full (g_direct_hash, g_direct_equal,
- NULL, (GDestroyNotify)free_cache_array);
+ NULL, (GDestroyNotify)free_cache_array);
priv->heights = g_hash_table_new_full (g_direct_hash, g_direct_equal,
- NULL, (GDestroyNotify)free_cache_array);
+ NULL, (GDestroyNotify)free_cache_array);
priv->alloc_width = 0;
priv->alloc_height = 0;
@@ -232,7 +232,7 @@ gtk_cell_area_box_context_finalize (GObject *object)
}
/*************************************************************
- * GtkCellAreaContextClass *
+ * GtkCellAreaContextClass *
*************************************************************/
static void
gtk_cell_area_box_context_reset (GtkCellAreaContext *context)
@@ -270,9 +270,9 @@ gtk_cell_area_box_context_reset (GtkCellAreaContext *context)
static GtkRequestedSize *
gtk_cell_area_box_context_get_requests (GtkCellAreaBoxContext *box_context,
- GtkOrientation orientation,
- gint for_size,
- gint *n_requests)
+ GtkOrientation orientation,
+ gint for_size,
+ gint *n_requests)
{
GtkCellAreaBoxContextPrivate *priv;
GtkRequestedSize *requests;
@@ -291,7 +291,7 @@ gtk_cell_area_box_context_get_requests (GtkCellAreaBoxContext *box_context,
size = &g_array_index (array, CachedSize, i);
if (size->nat_size > 0)
- visible_groups++;
+ visible_groups++;
}
requests = g_new (GtkRequestedSize, visible_groups);
@@ -301,12 +301,12 @@ gtk_cell_area_box_context_get_requests (GtkCellAreaBoxContext *box_context,
size = &g_array_index (array, CachedSize, i);
if (size->nat_size > 0)
- {
- requests[j].data = GINT_TO_POINTER (i);
- requests[j].minimum_size = size->min_size;
- requests[j].natural_size = size->nat_size;
- j++;
- }
+ {
+ requests[j].data = GINT_TO_POINTER (i);
+ requests[j].minimum_size = size->min_size;
+ requests[j].natural_size = size->nat_size;
+ j++;
+ }
}
if (n_requests)
@@ -317,11 +317,11 @@ gtk_cell_area_box_context_get_requests (GtkCellAreaBoxContext *box_context,
static GtkCellAreaBoxAllocation *
allocate_for_orientation (GtkCellAreaBoxContext *context,
- GtkOrientation orientation,
- gint spacing,
- gint size,
- gint for_size,
- gint *n_allocs)
+ GtkOrientation orientation,
+ gint spacing,
+ gint size,
+ gint for_size,
+ gint *n_allocs)
{
GtkCellAreaBoxAllocation *allocs;
GtkRequestedSize *sizes;
@@ -363,14 +363,14 @@ allocate_for_orientation (GtkCellAreaBoxContext *context,
allocs[i].size = sizes[i].minimum_size;
if (group_expands (context, allocs[i].group_idx))
- {
- allocs[i].size += extra_size;
- if (extra_extra)
- {
- allocs[i].size++;
- extra_extra--;
- }
- }
+ {
+ allocs[i].size += extra_size;
+ if (extra_extra)
+ {
+ allocs[i].size++;
+ extra_extra--;
+ }
+ }
position += allocs[i].size;
position += spacing;
@@ -386,8 +386,8 @@ allocate_for_orientation (GtkCellAreaBoxContext *context,
static void
gtk_cell_area_box_context_allocate (GtkCellAreaContext *context,
- gint width,
- gint height)
+ gint width,
+ gint height)
{
GtkCellAreaBoxContext *box_context = GTK_CELL_AREA_BOX_CONTEXT (context);
GtkCellAreaBoxContextPrivate *priv = box_context->priv;
@@ -405,22 +405,22 @@ gtk_cell_area_box_context_allocate (GtkCellAreaContext *context,
if (orientation == GTK_ORIENTATION_HORIZONTAL && width > 0)
priv->orientation_allocs = allocate_for_orientation (box_context, orientation,
- spacing, width, height,
- &priv->n_orientation_allocs);
+ spacing, width, height,
+ &priv->n_orientation_allocs);
else if (orientation == GTK_ORIENTATION_VERTICAL && height > 0)
priv->orientation_allocs = allocate_for_orientation (box_context, orientation,
- spacing, height, width,
- &priv->n_orientation_allocs);
+ spacing, height, width,
+ &priv->n_orientation_allocs);
GTK_CELL_AREA_CONTEXT_CLASS (gtk_cell_area_box_context_parent_class)->allocate (context, width, height);
}
static void
gtk_cell_area_box_context_sum (GtkCellAreaBoxContext *context,
- GtkOrientation orientation,
- gint for_size,
- gint *minimum_size,
- gint *natural_size)
+ GtkOrientation orientation,
+ gint for_size,
+ gint *minimum_size,
+ gint *natural_size)
{
GtkCellArea *area;
GtkOrientation box_orientation;
@@ -438,32 +438,32 @@ gtk_cell_area_box_context_sum (GtkCellAreaBoxContext *context,
CachedSize *size = &g_array_index (array, CachedSize, i);
if (box_orientation == orientation)
- {
- /* Dont add spacing for 0 size groups, they can be 0 size because
- * they contain only invisible cells for this round of requests
- */
- if (min_size > 0 && size->nat_size > 0)
- {
- min_size += spacing;
- nat_size += spacing;
- }
-
- min_size += size->min_size;
- nat_size += size->nat_size;
- }
+ {
+ /* Dont add spacing for 0 size groups, they can be 0 size because
+ * they contain only invisible cells for this round of requests
+ */
+ if (min_size > 0 && size->nat_size > 0)
+ {
+ min_size += spacing;
+ nat_size += spacing;
+ }
+
+ min_size += size->min_size;
+ nat_size += size->nat_size;
+ }
else
- {
- min_size = MAX (min_size, size->min_size);
- nat_size = MAX (nat_size, size->nat_size);
- }
+ {
+ min_size = MAX (min_size, size->min_size);
+ nat_size = MAX (nat_size, size->nat_size);
+ }
}
if (for_size < 0)
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
- gtk_cell_area_context_push_preferred_width (GTK_CELL_AREA_CONTEXT (context), min_size, nat_size);
+ gtk_cell_area_context_push_preferred_width (GTK_CELL_AREA_CONTEXT (context), min_size, nat_size);
else
- gtk_cell_area_context_push_preferred_height (GTK_CELL_AREA_CONTEXT (context), min_size, nat_size);
+ gtk_cell_area_context_push_preferred_height (GTK_CELL_AREA_CONTEXT (context), min_size, nat_size);
}
if (minimum_size)
@@ -474,22 +474,22 @@ gtk_cell_area_box_context_sum (GtkCellAreaBoxContext *context,
static void
gtk_cell_area_box_context_get_preferred_height_for_width (GtkCellAreaContext *context,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ gint width,
+ gint *minimum_height,
+ gint *natural_height)
{
gtk_cell_area_box_context_sum (GTK_CELL_AREA_BOX_CONTEXT (context), GTK_ORIENTATION_VERTICAL,
- width, minimum_height, natural_height);
+ width, minimum_height, natural_height);
}
static void
gtk_cell_area_box_context_get_preferred_width_for_height (GtkCellAreaContext *context,
- gint height,
- gint *minimum_width,
- gint *natural_width)
+ gint height,
+ gint *minimum_width,
+ gint *natural_width)
{
gtk_cell_area_box_context_sum (GTK_CELL_AREA_BOX_CONTEXT (context), GTK_ORIENTATION_HORIZONTAL,
- height, minimum_width, natural_width);
+ height, minimum_width, natural_width);
}
/*************************************************************
@@ -497,7 +497,7 @@ gtk_cell_area_box_context_get_preferred_width_for_height (GtkCellAreaContext *co
*************************************************************/
static void
copy_size_array (GArray *src_array,
- GArray *dest_array)
+ GArray *dest_array)
{
gint i;
@@ -512,8 +512,8 @@ copy_size_array (GArray *src_array,
static void
for_size_copy (gpointer key,
- GArray *size_array,
- GHashTable *dest_hash)
+ GArray *size_array,
+ GHashTable *dest_hash)
{
GArray *new_array;
@@ -527,52 +527,52 @@ for_size_copy (gpointer key,
GtkCellAreaBoxContext *
gtk_cell_area_box_context_copy (GtkCellAreaBox *box,
- GtkCellAreaBoxContext *context)
+ GtkCellAreaBoxContext *context)
{
GtkCellAreaBoxContext *copy;
- copy = g_object_new (GTK_TYPE_CELL_AREA_BOX_CONTEXT,
- "area", box, NULL);
+ copy = g_object_new (GTK_TYPE_CELL_AREA_BOX_CONTEXT,
+ "area", box, NULL);
- gtk_cell_area_box_init_groups (copy,
- context->priv->base_widths->len,
- context->priv->expand);
+ gtk_cell_area_box_init_groups (copy,
+ context->priv->base_widths->len,
+ context->priv->expand);
/* Copy the base arrays */
- copy_size_array (context->priv->base_widths,
- copy->priv->base_widths);
- copy_size_array (context->priv->base_heights,
- copy->priv->base_heights);
+ copy_size_array (context->priv->base_widths,
+ copy->priv->base_widths);
+ copy_size_array (context->priv->base_heights,
+ copy->priv->base_heights);
/* Copy each for size */
g_hash_table_foreach (context->priv->heights,
- (GHFunc)for_size_copy, copy->priv->heights);
+ (GHFunc)for_size_copy, copy->priv->heights);
g_hash_table_foreach (context->priv->widths,
- (GHFunc)for_size_copy, copy->priv->widths);
+ (GHFunc)for_size_copy, copy->priv->widths);
/* Copy any active allocation */
- copy->priv->n_orientation_allocs =
+ copy->priv->n_orientation_allocs =
context->priv->n_orientation_allocs;
if (copy->priv->n_orientation_allocs)
- copy->priv->orientation_allocs =
- g_memdup (context->priv->orientation_allocs,
- copy->priv->n_orientation_allocs * sizeof (GtkCellAreaBoxAllocation));
+ copy->priv->orientation_allocs =
+ g_memdup (context->priv->orientation_allocs,
+ copy->priv->n_orientation_allocs * sizeof (GtkCellAreaBoxAllocation));
return copy;
}
void
gtk_cell_area_box_init_groups (GtkCellAreaBoxContext *box_context,
- guint n_groups,
- gboolean *expand_groups)
+ guint n_groups,
+ gboolean *expand_groups)
{
GtkCellAreaBoxContextPrivate *priv;
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (box_context));
g_return_if_fail (n_groups == 0 || expand_groups != NULL);
- /* When the group dimensions change, all info must be reset
+ /* When the group dimensions change, all info must be reset
* Note this already clears the min/nat values on the CachedSizes
*/
gtk_cell_area_context_reset (GTK_CELL_AREA_CONTEXT (box_context));
@@ -587,9 +587,9 @@ gtk_cell_area_box_init_groups (GtkCellAreaBoxContext *box_context,
void
gtk_cell_area_box_context_push_group_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint minimum_width,
- gint natural_width)
+ gint group_idx,
+ gint minimum_width,
+ gint natural_width)
{
GtkCellAreaBoxContextPrivate *priv;
CachedSize *size;
@@ -618,10 +618,10 @@ gtk_cell_area_box_context_push_group_width (GtkCellAreaBoxContext *box_context,
void
gtk_cell_area_box_context_push_group_height_for_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_width,
- gint minimum_height,
- gint natural_height)
+ gint group_idx,
+ gint for_width,
+ gint minimum_height,
+ gint natural_height)
{
GtkCellAreaBoxContextPrivate *priv;
GArray *group_array;
@@ -646,9 +646,9 @@ gtk_cell_area_box_context_push_group_height_for_width (GtkCellAreaBoxContext *b
void
gtk_cell_area_box_context_push_group_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint minimum_height,
- gint natural_height)
+ gint group_idx,
+ gint minimum_height,
+ gint natural_height)
{
GtkCellAreaBoxContextPrivate *priv;
CachedSize *size;
@@ -677,10 +677,10 @@ gtk_cell_area_box_context_push_group_height (GtkCellAreaBoxContext *box_context,
void
gtk_cell_area_box_context_push_group_width_for_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_height,
- gint minimum_width,
- gint natural_width)
+ gint group_idx,
+ gint for_height,
+ gint minimum_width,
+ gint natural_width)
{
GtkCellAreaBoxContextPrivate *priv;
GArray *group_array;
@@ -705,9 +705,9 @@ gtk_cell_area_box_context_push_group_width_for_height (GtkCellAreaBoxContext *bo
void
gtk_cell_area_box_context_get_group_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint *minimum_width,
- gint *natural_width)
+ gint group_idx,
+ gint *minimum_width,
+ gint *natural_width)
{
GtkCellAreaBoxContextPrivate *priv;
CachedSize *size;
@@ -721,17 +721,17 @@ gtk_cell_area_box_context_get_group_width (GtkCellAreaBoxContext *box_context,
if (minimum_width)
*minimum_width = size->min_size;
-
+
if (natural_width)
*natural_width = size->nat_size;
}
void
gtk_cell_area_box_context_get_group_height_for_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_width,
- gint *minimum_height,
- gint *natural_height)
+ gint group_idx,
+ gint for_width,
+ gint *minimum_height,
+ gint *natural_height)
{
GtkCellAreaBoxContextPrivate *priv;
GArray *group_array;
@@ -748,26 +748,26 @@ gtk_cell_area_box_context_get_group_height_for_width (GtkCellAreaBoxContext *box
CachedSize *size = &g_array_index (group_array, CachedSize, group_idx);
if (minimum_height)
- *minimum_height = size->min_size;
+ *minimum_height = size->min_size;
if (natural_height)
- *natural_height = size->nat_size;
+ *natural_height = size->nat_size;
}
else
{
if (minimum_height)
- *minimum_height = -1;
+ *minimum_height = -1;
if (natural_height)
- *natural_height = -1;
+ *natural_height = -1;
}
}
void
gtk_cell_area_box_context_get_group_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint *minimum_height,
- gint *natural_height)
+ gint group_idx,
+ gint *minimum_height,
+ gint *natural_height)
{
GtkCellAreaBoxContextPrivate *priv;
CachedSize *size;
@@ -781,17 +781,17 @@ gtk_cell_area_box_context_get_group_height (GtkCellAreaBoxContext *box_context,
if (minimum_height)
*minimum_height = size->min_size;
-
+
if (natural_height)
*natural_height = size->nat_size;
}
void
gtk_cell_area_box_context_get_group_width_for_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_height,
- gint *minimum_width,
- gint *natural_width)
+ gint group_idx,
+ gint for_height,
+ gint *minimum_width,
+ gint *natural_width)
{
GtkCellAreaBoxContextPrivate *priv;
GArray *group_array;
@@ -808,43 +808,43 @@ gtk_cell_area_box_context_get_group_width_for_height (GtkCellAreaBoxContext *box
CachedSize *size = &g_array_index (group_array, CachedSize, group_idx);
if (minimum_width)
- *minimum_width = size->min_size;
+ *minimum_width = size->min_size;
if (natural_width)
- *natural_width = size->nat_size;
+ *natural_width = size->nat_size;
}
else
{
if (minimum_width)
- *minimum_width = -1;
+ *minimum_width = -1;
if (natural_width)
- *natural_width = -1;
+ *natural_width = -1;
}
}
GtkRequestedSize *
gtk_cell_area_box_context_get_widths (GtkCellAreaBoxContext *box_context,
- gint *n_widths)
+ gint *n_widths)
{
return gtk_cell_area_box_context_get_requests (box_context, GTK_ORIENTATION_HORIZONTAL, -1, n_widths);
}
GtkRequestedSize *
gtk_cell_area_box_context_get_heights (GtkCellAreaBoxContext *box_context,
- gint *n_heights)
+ gint *n_heights)
{
return gtk_cell_area_box_context_get_requests (box_context, GTK_ORIENTATION_VERTICAL, -1, n_heights);
}
GtkCellAreaBoxAllocation *
gtk_cell_area_box_context_get_orientation_allocs (GtkCellAreaBoxContext *context,
- gint *n_allocs)
+ gint *n_allocs)
{
GtkCellAreaBoxContextPrivate *priv;
g_return_val_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (context), NULL);
-
+
priv = context->priv;
*n_allocs = priv->n_orientation_allocs;
diff --git a/gtk/gtkcellareaboxcontext.h b/gtk/gtkcellareaboxcontext.h
index 1161d38..7d9f37e 100644
--- a/gtk/gtkcellareaboxcontext.h
+++ b/gtk/gtkcellareaboxcontext.h
@@ -35,10 +35,10 @@
G_BEGIN_DECLS
-#define GTK_TYPE_CELL_AREA_BOX_CONTEXT (gtk_cell_area_box_context_get_type ())
-#define GTK_CELL_AREA_BOX_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_AREA_BOX_CONTEXT, GtkCellAreaBoxContext))
-#define GTK_CELL_AREA_BOX_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_AREA_BOX_CONTEXT, GtkCellAreaBoxContextClass))
-#define GTK_IS_CELL_AREA_BOX_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_AREA_BOX_CONTEXT))
+#define GTK_TYPE_CELL_AREA_BOX_CONTEXT (gtk_cell_area_box_context_get_type ())
+#define GTK_CELL_AREA_BOX_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_AREA_BOX_CONTEXT, GtkCellAreaBoxContext))
+#define GTK_CELL_AREA_BOX_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_AREA_BOX_CONTEXT, GtkCellAreaBoxContextClass))
+#define GTK_IS_CELL_AREA_BOX_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_AREA_BOX_CONTEXT))
#define GTK_IS_CELL_AREA_BOX_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_AREA_BOX_CONTEXT))
#define GTK_CELL_AREA_BOX_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_AREA_BOX_CONTEXT, GtkCellAreaBoxContextClass))
@@ -64,63 +64,63 @@ GType gtk_cell_area_box_context_get_type (void) G_GNUC_CON
/* Create a duplicate of the context */
GtkCellAreaBoxContext *gtk_cell_area_box_context_copy (GtkCellAreaBox *box,
- GtkCellAreaBoxContext *box_context);
+ GtkCellAreaBoxContext *box_context);
/* Initialize group array dimensions */
void gtk_cell_area_box_init_groups (GtkCellAreaBoxContext *box_context,
- guint n_groups,
- gboolean *expand_groups);
+ guint n_groups,
+ gboolean *expand_groups);
/* Update cell-group sizes */
void gtk_cell_area_box_context_push_group_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint minimum_width,
- gint natural_width);
+ gint group_idx,
+ gint minimum_width,
+ gint natural_width);
void gtk_cell_area_box_context_push_group_height_for_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_width,
- gint minimum_height,
- gint natural_height);
+ gint group_idx,
+ gint for_width,
+ gint minimum_height,
+ gint natural_height);
void gtk_cell_area_box_context_push_group_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint minimum_height,
- gint natural_height);
+ gint group_idx,
+ gint minimum_height,
+ gint natural_height);
void gtk_cell_area_box_context_push_group_width_for_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_height,
- gint minimum_width,
- gint natural_width);
+ gint group_idx,
+ gint for_height,
+ gint minimum_width,
+ gint natural_width);
/* Fetch cell-group sizes */
void gtk_cell_area_box_context_get_group_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint *minimum_width,
- gint *natural_width);
+ gint group_idx,
+ gint *minimum_width,
+ gint *natural_width);
void gtk_cell_area_box_context_get_group_height_for_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_width,
- gint *minimum_height,
- gint *natural_height);
+ gint group_idx,
+ gint for_width,
+ gint *minimum_height,
+ gint *natural_height);
void gtk_cell_area_box_context_get_group_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint *minimum_height,
- gint *natural_height);
+ gint group_idx,
+ gint *minimum_height,
+ gint *natural_height);
void gtk_cell_area_box_context_get_group_width_for_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_height,
- gint *minimum_width,
- gint *natural_width);
+ gint group_idx,
+ gint for_height,
+ gint *minimum_width,
+ gint *natural_width);
GtkRequestedSize *gtk_cell_area_box_context_get_widths (GtkCellAreaBoxContext *box_context,
- gint *n_widths);
+ gint *n_widths);
GtkRequestedSize *gtk_cell_area_box_context_get_heights (GtkCellAreaBoxContext *box_context,
- gint *n_heights);
+ gint *n_heights);
/* Private context/area interaction */
typedef struct {
@@ -131,7 +131,7 @@ typedef struct {
GtkCellAreaBoxAllocation *
gtk_cell_area_box_context_get_orientation_allocs (GtkCellAreaBoxContext *context,
- gint *n_allocs);
+ gint *n_allocs);
G_END_DECLS
diff --git a/gtk/gtkcellareacontext.c b/gtk/gtkcellareacontext.c
index 44c718a..d2249d9 100644
--- a/gtk/gtkcellareacontext.c
+++ b/gtk/gtkcellareacontext.c
@@ -23,18 +23,22 @@
/**
* SECTION:gtkcellareacontext
- * @Short_Description: An object for a GtkCellArea to store geometrical information for a series of rows.
+ * @Short_Description: An object for a GtkCellArea to store geometrical
+ * information for a series of rows.
* @Title: GtkCellAreaContext
*
- * The #GtkCellAreaContext object is created by a given #GtkCellArea implementation via it's
- * #GtkCellAreaClass.create_context() virtual method and is used to store cell sizes and alignments
- * for a series of #GtkTreeModel rows that are requested and rendered in the same context.
+ * The #GtkCellAreaContext object is created by a given #GtkCellArea
+ * implementation via it's #GtkCellAreaClass.create_context() virtual
+ * method and is used to store cell sizes and alignments for a series of
+ * #GtkTreeModel rows that are requested and rendered in the same context.
*
- * #GtkCellLayout widgets can create any number of contexts in which to request and render
- * groups of data rows. However its important that the same context which was used to
- * request sizes for a given #GtkTreeModel row also be used for the same row when calling
- * other #GtkCellArea apis such as gtk_cell_area_render() and gtk_cell_area_event().
+ * #GtkCellLayout widgets can create any number of contexts in which to
+ * request and render groups of data rows. However its important that the
+ * same context which was used to request sizes for a given #GtkTreeModel
+ * row also be used for the same row when calling other #GtkCellArea APIs
+ * such as gtk_cell_area_render() and gtk_cell_area_event().
*/
+
#include "config.h"
#include "gtkintl.h"
#include "gtkmarshalers.h"
@@ -42,21 +46,21 @@
#include "gtkprivate.h"
/* GObjectClass */
-static void gtk_cell_area_context_dispose (GObject *object);
-static void gtk_cell_area_context_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec);
-static void gtk_cell_area_context_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec);
+static void gtk_cell_area_context_dispose (GObject *object);
+static void gtk_cell_area_context_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void gtk_cell_area_context_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
/* GtkCellAreaContextClass */
-static void gtk_cell_area_context_real_reset (GtkCellAreaContext *context);
-static void gtk_cell_area_context_real_allocate (GtkCellAreaContext *context,
- gint width,
- gint height);
+static void gtk_cell_area_context_real_reset (GtkCellAreaContext *context);
+static void gtk_cell_area_context_real_allocate (GtkCellAreaContext *context,
+ gint width,
+ gint height);
struct _GtkCellAreaContextPrivate
{
@@ -87,8 +91,8 @@ gtk_cell_area_context_init (GtkCellAreaContext *context)
GtkCellAreaContextPrivate *priv;
context->priv = G_TYPE_INSTANCE_GET_PRIVATE (context,
- GTK_TYPE_CELL_AREA_CONTEXT,
- GtkCellAreaContextPrivate);
+ GTK_TYPE_CELL_AREA_CONTEXT,
+ GtkCellAreaContextPrivate);
priv = context->priv;
priv->min_width = -1;
@@ -97,7 +101,7 @@ gtk_cell_area_context_init (GtkCellAreaContext *context)
priv->nat_height = -1;
}
-static void
+static void
gtk_cell_area_context_class_init (GtkCellAreaContextClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS (class);
@@ -121,10 +125,10 @@ gtk_cell_area_context_class_init (GtkCellAreaContextClass *class)
g_object_class_install_property (object_class,
PROP_CELL_AREA,
g_param_spec_object ("area",
- P_("Area"),
- P_("The Cell Area this context was created for"),
- GTK_TYPE_CELL_AREA,
- GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+ P_("Area"),
+ P_("The Cell Area this context was created for"),
+ GTK_TYPE_CELL_AREA,
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
/**
* GtkCellAreaContext:minimum-width:
@@ -138,12 +142,12 @@ gtk_cell_area_context_class_init (GtkCellAreaContextClass *class)
g_object_class_install_property (object_class,
PROP_MIN_WIDTH,
g_param_spec_int ("minimum-width",
- P_("Minimum Width"),
- P_("Minimum cached width"),
- -1,
- G_MAXINT,
- -1,
- G_PARAM_READABLE));
+ P_("Minimum Width"),
+ P_("Minimum cached width"),
+ -1,
+ G_MAXINT,
+ -1,
+ G_PARAM_READABLE));
/**
* GtkCellAreaContext:natural-width:
@@ -157,12 +161,12 @@ gtk_cell_area_context_class_init (GtkCellAreaContextClass *class)
g_object_class_install_property (object_class,
PROP_NAT_WIDTH,
g_param_spec_int ("natural-width",
- P_("Minimum Width"),
- P_("Minimum cached width"),
- -1,
- G_MAXINT,
- -1,
- G_PARAM_READABLE));
+ P_("Minimum Width"),
+ P_("Minimum cached width"),
+ -1,
+ G_MAXINT,
+ -1,
+ G_PARAM_READABLE));
/**
* GtkCellAreaContext:minimum-height:
@@ -176,12 +180,12 @@ gtk_cell_area_context_class_init (GtkCellAreaContextClass *class)
g_object_class_install_property (object_class,
PROP_MIN_HEIGHT,
g_param_spec_int ("minimum-height",
- P_("Minimum Height"),
- P_("Minimum cached height"),
- -1,
- G_MAXINT,
- -1,
- G_PARAM_READABLE));
+ P_("Minimum Height"),
+ P_("Minimum cached height"),
+ -1,
+ G_MAXINT,
+ -1,
+ G_PARAM_READABLE));
/**
* GtkCellAreaContext:natural-height:
@@ -195,12 +199,12 @@ gtk_cell_area_context_class_init (GtkCellAreaContextClass *class)
g_object_class_install_property (object_class,
PROP_NAT_HEIGHT,
g_param_spec_int ("natural-height",
- P_("Minimum Height"),
- P_("Minimum cached height"),
- -1,
- G_MAXINT,
- -1,
- G_PARAM_READABLE));
+ P_("Minimum Height"),
+ P_("Minimum cached height"),
+ -1,
+ G_MAXINT,
+ -1,
+ G_PARAM_READABLE));
g_type_class_add_private (object_class, sizeof (GtkCellAreaContextPrivate));
}
@@ -226,9 +230,9 @@ gtk_cell_area_context_dispose (GObject *object)
static void
gtk_cell_area_context_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec)
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
GtkCellAreaContext *context = GTK_CELL_AREA_CONTEXT (object);
GtkCellAreaContextPrivate *priv = context->priv;
@@ -246,9 +250,9 @@ gtk_cell_area_context_set_property (GObject *object,
static void
gtk_cell_area_context_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
GtkCellAreaContext *context = GTK_CELL_AREA_CONTEXT (object);
GtkCellAreaContextPrivate *priv = context->priv;
@@ -277,13 +281,13 @@ gtk_cell_area_context_get_property (GObject *object,
}
/*************************************************************
- * GtkCellAreaContextClass *
+ * GtkCellAreaContextClass *
*************************************************************/
static void
gtk_cell_area_context_real_reset (GtkCellAreaContext *context)
{
GtkCellAreaContextPrivate *priv = context->priv;
-
+
g_object_freeze_notify (G_OBJECT (context));
if (priv->min_width != -1)
@@ -318,8 +322,8 @@ gtk_cell_area_context_real_reset (GtkCellAreaContext *context)
static void
gtk_cell_area_context_real_allocate (GtkCellAreaContext *context,
- gint width,
- gint height)
+ gint width,
+ gint height)
{
GtkCellAreaContextPrivate *priv = context->priv;
@@ -336,13 +340,13 @@ gtk_cell_area_context_real_allocate (GtkCellAreaContext *context,
*
* Fetches the #GtkCellArea this @context was created by.
*
- * This is generally unneeded by layouting widgets however
- * its important for the context implementation itself to
+ * This is generally unneeded by layouting widgets; however
+ * it is important for the context implementation itself to
* fetch information about the area it is being used for.
*
* For instance at #GtkCellAreaContextClass.allocate() time
* it's important to know details about any cell spacing
- * that the #GtkCellArea is configured with in order to
+ * that the #GtkCellArea is configured with in order to
* compute a proper allocation.
*
* Return value: the #GtkCellArea this context was created by.
@@ -366,15 +370,15 @@ gtk_cell_area_context_get_area (GtkCellAreaContext *context)
* @context: a #GtkCellAreaContext
*
* Resets any previously cached request and allocation
- * data.
+ * data.
*
- * When underlying #GtkTreeModel data changes it's
+ * When underlying #GtkTreeModel data changes it's
* important to reset the context if the content
* size is allowed to shrink. If the content size
* is only allowed to grow (this is usually an option
* for views rendering large data stores as a measure
* of optimization), then only the row that changed
- * or was inserted needs to be (re)requested with
+ * or was inserted needs to be (re)requested with
* gtk_cell_area_get_preferred_width().
*
* When the new overall size of the context requires
@@ -401,24 +405,28 @@ gtk_cell_area_context_reset (GtkCellAreaContext *context)
/**
* gtk_cell_area_context_allocate:
* @context: a #GtkCellAreaContext
- * @width: the allocated width for all #GtkTreeModel rows rendered with @context, or -1.
- * @height: the allocated height for all #GtkTreeModel rows rendered with @context, or -1.
- *
- * Allocates a width and/or a height for all rows which are to be rendered with @context.
- *
- * Usually allocation is performed only horizontally or sometimes vertically since
- * a group of rows are usually rendered side by side vertically or horizontally and
- * share either the same width or the same hieght. Sometimes they are allocated in
- * both horizontal and vertical orientations producing a homogenious effect of the
- * rows. This is generally the case for #GtkTreeView when #GtkTreeView:fixed-height-mode
- * is enabled.
+ * @width: the allocated width for all #GtkTreeModel rows rendered
+ * with @context, or -1.
+ * @height: the allocated height for all #GtkTreeModel rows rendered
+ * with @context, or -1.
+ *
+ * Allocates a width and/or a height for all rows which are to be
+ * rendered with @context.
+ *
+ * Usually allocation is performed only horizontally or sometimes
+ * vertically since a group of rows are usually rendered side by
+ * side vertically or horizontally and share either the same width
+ * or the same height. Sometimes they are allocated in both horizontal
+ * and vertical orientations producing a homogeneous effect of the
+ * rows. This is generally the case for #GtkTreeView when
+ * #GtkTreeView:fixed-height-mode is enabled.
*
* Since 3.0
*/
void
gtk_cell_area_context_allocate (GtkCellAreaContext *context,
- gint width,
- gint height)
+ gint width,
+ gint height)
{
g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
@@ -428,21 +436,23 @@ gtk_cell_area_context_allocate (GtkCellAreaContext *context,
/**
* gtk_cell_area_context_get_preferred_width:
* @context: a #GtkCellAreaContext
- * @minimum_width: (out) (allow-none): location to store the minimum width, or %NULL
- * @natural_width: (out) (allow-none): location to store the natural width, or %NULL
+ * @minimum_width: (out) (allow-none): location to store the minimum width,
+ * or %NULL
+ * @natural_width: (out) (allow-none): location to store the natural width,
+ * or %NULL
*
- * Gets the accumulative preferred width for all rows which have been requested
- * with this context.
+ * Gets the accumulative preferred width for all rows which have been
+ * requested with this context.
*
- * After gtk_cell_area_context_reset() is called and/or before ever requesting
- * the size of a #GtkCellArea, the returned values are -1.
+ * After gtk_cell_area_context_reset() is called and/or before ever
+ * requesting the size of a #GtkCellArea, the returned values are -1.
*
- * Since: 3.0
+ * Since: 3.0
*/
void
gtk_cell_area_context_get_preferred_width (GtkCellAreaContext *context,
- gint *minimum_width,
- gint *natural_width)
+ gint *minimum_width,
+ gint *natural_width)
{
GtkCellAreaContextPrivate *priv;
@@ -460,21 +470,23 @@ gtk_cell_area_context_get_preferred_width (GtkCellAreaContext *context,
/**
* gtk_cell_area_context_get_preferred_height:
* @context: a #GtkCellAreaContext
- * @minimum_height: (out) (allow-none): location to store the minimum height, or %NULL
- * @natural_height: (out) (allow-none): location to store the natural height, or %NULL
+ * @minimum_height: (out) (allow-none): location to store the minimum height,
+ * or %NULL
+ * @natural_height: (out) (allow-none): location to store the natural height,
+ * or %NULL
*
- * Gets the accumulative preferred height for all rows which have been requested
- * with this context.
+ * Gets the accumulative preferred height for all rows which have been
+ * requested with this context.
*
- * After gtk_cell_area_context_reset() is called and/or before ever requesting
- * the size of a #GtkCellArea, the returned values are -1.
+ * After gtk_cell_area_context_reset() is called and/or before ever
+ * requesting the size of a #GtkCellArea, the returned values are -1.
*
* Since: 3.0
*/
void
gtk_cell_area_context_get_preferred_height (GtkCellAreaContext *context,
- gint *minimum_height,
- gint *natural_height)
+ gint *minimum_height,
+ gint *natural_height)
{
GtkCellAreaContextPrivate *priv;
@@ -493,67 +505,71 @@ gtk_cell_area_context_get_preferred_height (GtkCellAreaContext *context,
* gtk_cell_area_context_get_preferred_height_for_width:
* @context: a #GtkCellAreaContext
* @width: a proposed width for allocation
- * @minimum_height: (out) (allow-none): location to store the minimum height, or %NULL
- * @natural_height: (out) (allow-none): location to store the natural height, or %NULL
+ * @minimum_height: (out) (allow-none): location to store the minimum height,
+ * or %NULL
+ * @natural_height: (out) (allow-none): location to store the natural height,
+ * or %NULL
*
- * Gets the accumulative preferred height for @width for all rows which have been
- * requested for the same said @width with this context.
+ * Gets the accumulative preferred height for @width for all rows
+ * which have been requested for the same said @width with this context.
*
- * After gtk_cell_area_context_reset() is called and/or before ever requesting
- * the size of a #GtkCellArea, the returned values are -1.
+ * After gtk_cell_area_context_reset() is called and/or before ever
+ * requesting the size of a #GtkCellArea, the returned values are -1.
*
* Since: 3.0
*/
void
gtk_cell_area_context_get_preferred_height_for_width (GtkCellAreaContext *context,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ gint width,
+ gint *minimum_height,
+ gint *natural_height)
{
g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
if (GTK_CELL_AREA_CONTEXT_GET_CLASS (context)->get_preferred_height_for_width)
GTK_CELL_AREA_CONTEXT_GET_CLASS (context)->get_preferred_height_for_width (context,
- width,
- minimum_height,
- natural_height);
+ width,
+ minimum_height,
+ natural_height);
}
/**
* gtk_cell_area_context_get_preferred_width_for_height:
* @context: a #GtkCellAreaContext
* @height: a proposed height for allocation
- * @minimum_width: (out) (allow-none): location to store the minimum width, or %NULL
- * @natural_width: (out) (allow-none): location to store the natural width, or %NULL
+ * @minimum_width: (out) (allow-none): location to store the minimum width,
+ * or %NULL
+ * @natural_width: (out) (allow-none): location to store the natural width,
+ * or %NULL
*
- * Gets the accumulative preferred width for @height for all rows which have
- * been requested for the same said @height with this context.
+ * Gets the accumulative preferred width for @height for all rows which
+ * have been requested for the same said @height with this context.
*
- * After gtk_cell_area_context_reset() is called and/or before ever requesting
- * the size of a #GtkCellArea, the returned values are -1.
+ * After gtk_cell_area_context_reset() is called and/or before ever
+ * requesting the size of a #GtkCellArea, the returned values are -1.
*
- * Since: 3.0
+ * Since: 3.0
*/
void
gtk_cell_area_context_get_preferred_width_for_height (GtkCellAreaContext *context,
- gint height,
- gint *minimum_width,
- gint *natural_width)
-{
+ gint height,
+ gint *minimum_width,
+ gint *natural_width)
+{
g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
if (GTK_CELL_AREA_CONTEXT_GET_CLASS (context)->get_preferred_width_for_height)
GTK_CELL_AREA_CONTEXT_GET_CLASS (context)->get_preferred_width_for_height (context,
- height,
- minimum_width,
- natural_width);
+ height,
+ minimum_width,
+ natural_width);
}
/**
* gtk_cell_area_context_get_allocation:
* @context: a #GtkCellAreaContext
- * @width: (out) (allow-none): location to store the allocated width, or %NULL.
- * @height: (out) (allow-none): location to store the allocated height, or %NULL.
+ * @width: (out) (allow-none): location to store the allocated width, or %NULL
+ * @height: (out) (allow-none): location to store the allocated height, or %NULL
*
* Fetches the current allocation size for @context.
*
@@ -565,8 +581,8 @@ gtk_cell_area_context_get_preferred_width_for_height (GtkCellAreaContext *contex
*/
void
gtk_cell_area_context_get_allocation (GtkCellAreaContext *context,
- gint *width,
- gint *height)
+ gint *width,
+ gint *height)
{
GtkCellAreaContextPrivate *priv;
@@ -584,8 +600,8 @@ gtk_cell_area_context_get_allocation (GtkCellAreaContext *context,
/**
* gtk_cell_area_context_push_preferred_width:
* @context: a #GtkCellAreaContext
- * @minimum_width: the proposed new minimum width for @context.
- * @natural_width: the proposed new natural width for @context.
+ * @minimum_width: the proposed new minimum width for @context
+ * @natural_width: the proposed new natural width for @context
*
* Causes the minimum and/or natural width to grow if the new
* proposed sizes exceed the current minimum and natural width.
@@ -599,8 +615,8 @@ gtk_cell_area_context_get_allocation (GtkCellAreaContext *context,
*/
void
gtk_cell_area_context_push_preferred_width (GtkCellAreaContext *context,
- gint minimum_width,
- gint natural_width)
+ gint minimum_width,
+ gint natural_width)
{
GtkCellAreaContextPrivate *priv;
@@ -630,8 +646,8 @@ gtk_cell_area_context_push_preferred_width (GtkCellAreaContext *context,
/**
* gtk_cell_area_context_push_preferred_height:
* @context: a #GtkCellAreaContext
- * @minimum_height: the proposed new minimum height for @context.
- * @natural_height: the proposed new natural height for @context.
+ * @minimum_height: the proposed new minimum height for @context
+ * @natural_height: the proposed new natural height for @context
*
* Causes the minimum and/or natural height to grow if the new
* proposed sizes exceed the current minimum and natural height.
@@ -645,11 +661,11 @@ gtk_cell_area_context_push_preferred_width (GtkCellAreaContext *context,
*/
void
gtk_cell_area_context_push_preferred_height (GtkCellAreaContext *context,
- gint minimum_height,
- gint natural_height)
+ gint minimum_height,
+ gint natural_height)
{
GtkCellAreaContextPrivate *priv;
-
+
g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
priv = context->priv;
diff --git a/gtk/gtkcellareacontext.h b/gtk/gtkcellareacontext.h
index 3c3522b..787344e 100644
--- a/gtk/gtkcellareacontext.h
+++ b/gtk/gtkcellareacontext.h
@@ -32,10 +32,10 @@
G_BEGIN_DECLS
-#define GTK_TYPE_CELL_AREA_CONTEXT (gtk_cell_area_context_get_type ())
-#define GTK_CELL_AREA_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_AREA_CONTEXT, GtkCellAreaContext))
+#define GTK_TYPE_CELL_AREA_CONTEXT (gtk_cell_area_context_get_type ())
+#define GTK_CELL_AREA_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_AREA_CONTEXT, GtkCellAreaContext))
#define GTK_CELL_AREA_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_AREA_CONTEXT, GtkCellAreaContextClass))
-#define GTK_IS_CELL_AREA_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_AREA_CONTEXT))
+#define GTK_IS_CELL_AREA_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_AREA_CONTEXT))
#define GTK_IS_CELL_AREA_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_AREA_CONTEXT))
#define GTK_CELL_AREA_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_AREA_CONTEXT, GtkCellAreaContextClass))
@@ -52,16 +52,16 @@ struct _GtkCellAreaContext
/**
* GtkCellAreaContextClass:
- * @allocate: This tells the context that an allocation width or height (or both)
- * have been decided for a group of rows. The context should store any allocations
- * for internally aligned cells at this point so that they dont need to be
- * recalculated at gtk_cell_area_render() time.
- * @reset: Clear any previously stored information about requested and allocated
- * sizes for the context.
- * @get_preferred_height_for_width: Returns the aligned height for the given width
- * that context must store while collecting sizes for it's rows.
- * @get_preferred_width_for_height: Returns the aligned width for the given height
- * that context must store while collecting sizes for it's rows.
+ * @allocate: This tells the context that an allocation width or height
+ * (or both) have been decided for a group of rows. The context should
+ * store any allocations for internally aligned cells at this point so
+ * that they dont need to be recalculated at gtk_cell_area_render() time.
+ * @reset: Clear any previously stored information about requested and
+ * allocated sizes for the context.
+ * @get_preferred_height_for_width: Returns the aligned height for the given
+ * width that context must store while collecting sizes for it's rows.
+ * @get_preferred_width_for_height: Returns the aligned width for the given
+ * height that context must store while collecting sizes for it's rows.
*/
struct _GtkCellAreaContextClass
{
@@ -70,17 +70,17 @@ struct _GtkCellAreaContextClass
/*< public >*/
void (* allocate) (GtkCellAreaContext *context,
- gint width,
- gint height);
+ gint width,
+ gint height);
void (* reset) (GtkCellAreaContext *context);
void (* get_preferred_height_for_width) (GtkCellAreaContext *context,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ gint width,
+ gint *minimum_height,
+ gint *natural_height);
void (* get_preferred_width_for_height) (GtkCellAreaContext *context,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ gint height,
+ gint *minimum_width,
+ gint *natural_width);
/*< private >*/
/* Padding for future expansion */
@@ -97,36 +97,40 @@ GType gtk_cell_area_context_get_type (void) G_GNUC_CONST;
/* Main apis */
GtkCellArea *gtk_cell_area_context_get_area (GtkCellAreaContext *context);
void gtk_cell_area_context_allocate (GtkCellAreaContext *context,
- gint width,
- gint height);
+ gint width,
+ gint height);
void gtk_cell_area_context_reset (GtkCellAreaContext *context);
-/* Apis for GtkCellArea clients to consult cached values for a series of GtkTreeModel rows */
+/* Apis for GtkCellArea clients to consult cached values
+ * for a series of GtkTreeModel rows
+ */
void gtk_cell_area_context_get_preferred_width (GtkCellAreaContext *context,
- gint *minimum_width,
- gint *natural_width);
+ gint *minimum_width,
+ gint *natural_width);
void gtk_cell_area_context_get_preferred_height (GtkCellAreaContext *context,
- gint *minimum_height,
- gint *natural_height);
+ gint *minimum_height,
+ gint *natural_height);
void gtk_cell_area_context_get_preferred_height_for_width (GtkCellAreaContext *context,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ gint width,
+ gint *minimum_height,
+ gint *natural_height);
void gtk_cell_area_context_get_preferred_width_for_height (GtkCellAreaContext *context,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ gint height,
+ gint *minimum_width,
+ gint *natural_width);
void gtk_cell_area_context_get_allocation (GtkCellAreaContext *context,
- gint *width,
- gint *height);
+ gint *width,
+ gint *height);
-/* Apis for GtkCellArea implementations to update cached values for multiple GtkTreeModel rows */
+/* Apis for GtkCellArea implementations to update cached values
+ * for multiple GtkTreeModel rows
+ */
void gtk_cell_area_context_push_preferred_width (GtkCellAreaContext *context,
- gint minimum_width,
- gint natural_width);
+ gint minimum_width,
+ gint natural_width);
void gtk_cell_area_context_push_preferred_height (GtkCellAreaContext *context,
- gint minimum_height,
- gint natural_height);
+ gint minimum_height,
+ gint natural_height);
G_END_DECLS
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
