AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
97e060b094
gtk2/gtk/gtkcellareaboxcontext.c

741 lines
22 KiB
C
Raw Normal View History

Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
/* gtkcellareaboxcontext.c
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
*
* Copyright (C) 2010 Openismus GmbH
*
* Authors:
* Tristan Van Berkom <tristanvb@openismus.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include "gtkintl.h"
Made GtkCellAreaBox:align-cells a packing property per cell Implemented all request apis on GtkCellAreaBox considering alignment of groups of cells (some cells can be aligned while others fill space smartly).
2010-10-30 08:32:15 +00:00
#include "gtkcellareabox.h"
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
#include "gtkcellareaboxcontext.h"
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
#include "gtkorientable.h"
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
/* GObjectClass */
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
static void gtk_cell_area_box_context_finalize (GObject *object);
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
/* GtkCellAreaContextClass */
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
static void gtk_cell_area_box_context_reset (GtkCellAreaContext *context);
static void gtk_cell_area_box_context_allocate (GtkCellAreaContext *context,
gint width,
gint height);
/* Internal functions */
Removed gtk_cell_area_context_sum_preferred_width/height apis. Turns out theres not much reason to do this in a separate api, now we just sum up the sizes of aligned cell groups in GtkCellAreaContextBox when pushing the group size.
2010-11-28 09:52:08 +00:00
static void gtk_cell_area_box_context_sum (GtkCellAreaBoxContext *context,
GtkOrientation orientation);
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
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);
static gboolean group_expands (GtkCellAreaBoxContext *context,
gint group_idx);
static gint count_expand_groups (GtkCellAreaBoxContext *context);
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
/* CachedSize management */
typedef struct {
gint min_size;
gint nat_size;
} CachedSize;
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
struct _GtkCellAreaBoxContextPrivate
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
{
/* Table of per renderer CachedSizes */
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
GArray *base_widths;
GArray *base_heights;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
/* Table of per height/width hash tables of per renderer CachedSizes */
GHashTable *widths;
GHashTable *heights;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
/* Whether each group expands */
gboolean *expand;
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
/* Allocation info for this context if any */
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
gint alloc_width;
gint alloc_height;
gint n_orientation_allocs;
GtkCellAreaBoxAllocation *orientation_allocs;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
};
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
G_DEFINE_TYPE (GtkCellAreaBoxContext, gtk_cell_area_box_context, GTK_TYPE_CELL_AREA_CONTEXT);
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
static void
free_cache_array (GArray *array)
{
g_array_free (array, TRUE);
}
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
static GArray *
group_array_new (GtkCellAreaBoxContext *context)
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
GArray *group_array;
group_array = g_array_new (FALSE, TRUE, sizeof (CachedSize));
g_array_set_size (group_array, priv->base_widths->len);
return group_array;
}
static GArray *
get_array (GtkCellAreaBoxContext *context,
GtkOrientation orientation,
gint for_size)
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
GArray *array;
if (for_size < 0)
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
array = priv->base_widths;
else
array = priv->base_heights;
}
else
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
array = g_hash_table_lookup (priv->widths, GINT_TO_POINTER (for_size));
if (!array)
array = priv->base_widths;
}
else
{
array = g_hash_table_lookup (priv->heights, GINT_TO_POINTER (for_size));
if (!array)
array = priv->base_heights;
}
}
return array;
}
static gboolean
group_expands (GtkCellAreaBoxContext *context,
gint group_idx)
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
g_assert (group_idx >= 0 && group_idx < priv->base_widths->len);
return priv->expand[group_idx];
}
static gint
count_expand_groups (GtkCellAreaBoxContext *context)
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
gint i, expand = 0;
for (i = 0; i < priv->base_widths->len; i++)
{
if (priv->expand[i])
expand++;
}
return expand;
}
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
static void
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_box_context_init (GtkCellAreaBoxContext *box_context)
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GtkCellAreaBoxContextPrivate *priv;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
box_context->priv = G_TYPE_INSTANCE_GET_PRIVATE (box_context,
GTK_TYPE_CELL_AREA_BOX_CONTEXT,
GtkCellAreaBoxContextPrivate);
priv = box_context->priv;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
priv->base_widths = g_array_new (FALSE, TRUE, sizeof (CachedSize));
priv->base_heights = g_array_new (FALSE, TRUE, sizeof (CachedSize));
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
priv->widths = g_hash_table_new_full (g_direct_hash, g_direct_equal,
NULL, (GDestroyNotify)free_cache_array);
priv->heights = g_hash_table_new_full (g_direct_hash, g_direct_equal,
NULL, (GDestroyNotify)free_cache_array);
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
priv->alloc_width = 0;
priv->alloc_height = 0;
priv->orientation_allocs = NULL;
priv->n_orientation_allocs = 0;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
}
static void
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_box_context_class_init (GtkCellAreaBoxContextClass *class)
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GObjectClass *object_class = G_OBJECT_CLASS (class);
GtkCellAreaContextClass *context_class = GTK_CELL_AREA_CONTEXT_CLASS (class);
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
/* GObjectClass */
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
object_class->finalize = gtk_cell_area_box_context_finalize;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Removed gtk_cell_area_context_sum_preferred_width/height apis. Turns out theres not much reason to do this in a separate api, now we just sum up the sizes of aligned cell groups in GtkCellAreaContextBox when pushing the group size.
2010-11-28 09:52:08 +00:00
context_class->reset = gtk_cell_area_box_context_reset;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
context_class->allocate = gtk_cell_area_box_context_allocate;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
g_type_class_add_private (object_class, sizeof (GtkCellAreaBoxContextPrivate));
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
}
/*************************************************************
* GObjectClass *
*************************************************************/
static void
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_box_context_finalize (GObject *object)
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GtkCellAreaBoxContext *box_context = GTK_CELL_AREA_BOX_CONTEXT (object);
GtkCellAreaBoxContextPrivate *priv = box_context->priv;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
g_array_free (priv->base_widths, TRUE);
g_array_free (priv->base_heights, TRUE);
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
g_hash_table_destroy (priv->widths);
g_hash_table_destroy (priv->heights);
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
g_free (priv->orientation_allocs);
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
g_free (priv->expand);
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
G_OBJECT_CLASS (gtk_cell_area_box_context_parent_class)->finalize (object);
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
}
/*************************************************************
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
* GtkCellAreaContextClass *
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
*************************************************************/
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
static void
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
gtk_cell_area_box_context_reset (GtkCellAreaContext *context)
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GtkCellAreaBoxContext *box_context = GTK_CELL_AREA_BOX_CONTEXT (context);
GtkCellAreaBoxContextPrivate *priv = box_context->priv;
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
CachedSize *size;
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gint i;
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
for (i = 0; i < priv->base_widths->len; i++)
{
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
size = &g_array_index (priv->base_widths, CachedSize, i);
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
size->min_size = 0;
size->nat_size = 0;
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
size = &g_array_index (priv->base_heights, CachedSize, i);
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
size->min_size = 0;
size->nat_size = 0;
}
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
/* Reset context sizes as well */
g_hash_table_remove_all (priv->widths);
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
g_hash_table_remove_all (priv->heights);
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
/* Clear the allocation */
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
g_free (priv->orientation_allocs);
priv->orientation_allocs = NULL;
priv->n_orientation_allocs = 0;
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
GTK_CELL_AREA_CONTEXT_CLASS
(gtk_cell_area_box_context_parent_class)->reset (context);
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
}
Account for the possibility of invisible cells in GtkCellAreaBox/Iter Also changed the GtkCellAreaBox to keep groups in an array instead of a list, for this code it's generally more useful this way (and more optimized).
2010-11-02 07:51:06 +00:00
static GtkRequestedSize *
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_box_context_get_requests (GtkCellAreaBoxContext *box_context,
GtkOrientation orientation,
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
gint for_size,
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gint *n_requests)
Account for the possibility of invisible cells in GtkCellAreaBox/Iter Also changed the GtkCellAreaBox to keep groups in an array instead of a list, for this code it's generally more useful this way (and more optimized).
2010-11-02 07:51:06 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GtkCellAreaBoxContextPrivate *priv;
GtkRequestedSize *requests;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
GArray *array;
CachedSize *size;
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gint visible_groups = 0;
gint i, j;
Account for the possibility of invisible cells in GtkCellAreaBox/Iter Also changed the GtkCellAreaBox to keep groups in an array instead of a list, for this code it's generally more useful this way (and more optimized).
2010-11-02 07:51:06 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
g_return_val_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (box_context), NULL);
Account for the possibility of invisible cells in GtkCellAreaBox/Iter Also changed the GtkCellAreaBox to keep groups in an array instead of a list, for this code it's generally more useful this way (and more optimized).
2010-11-02 07:51:06 +00:00
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
priv = box_context->priv;
array = get_array (box_context, orientation, for_size);
Account for the possibility of invisible cells in GtkCellAreaBox/Iter Also changed the GtkCellAreaBox to keep groups in an array instead of a list, for this code it's generally more useful this way (and more optimized).
2010-11-02 07:51:06 +00:00
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
for (i = 0; i < array->len; i++)
Account for the possibility of invisible cells in GtkCellAreaBox/Iter Also changed the GtkCellAreaBox to keep groups in an array instead of a list, for this code it's generally more useful this way (and more optimized).
2010-11-02 07:51:06 +00:00
{
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
size = &g_array_index (array, CachedSize, i);
Account for the possibility of invisible cells in GtkCellAreaBox/Iter Also changed the GtkCellAreaBox to keep groups in an array instead of a list, for this code it's generally more useful this way (and more optimized).
2010-11-02 07:51:06 +00:00
if (size->nat_size > 0)
visible_groups++;
}
requests = g_new (GtkRequestedSize, visible_groups);
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
for (j = 0, i = 0; i < array->len; i++)
Account for the possibility of invisible cells in GtkCellAreaBox/Iter Also changed the GtkCellAreaBox to keep groups in an array instead of a list, for this code it's generally more useful this way (and more optimized).
2010-11-02 07:51:06 +00:00
{
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
size = &g_array_index (array, CachedSize, i);
Account for the possibility of invisible cells in GtkCellAreaBox/Iter Also changed the GtkCellAreaBox to keep groups in an array instead of a list, for this code it's generally more useful this way (and more optimized).
2010-11-02 07:51:06 +00:00
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++;
}
}
if (n_requests)
*n_requests = visible_groups;
return requests;
}
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
static GtkCellAreaBoxAllocation *
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
allocate_for_orientation (GtkCellAreaBoxContext *context,
GtkOrientation orientation,
gint spacing,
gint size,
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
gint for_size,
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gint *n_allocs)
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GtkCellAreaBoxAllocation *allocs;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
GtkRequestedSize *sizes;
GArray *array;
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gint n_expand_groups = 0;
gint i, n_groups, position;
gint extra_size, extra_extra;
gint avail_size = size;
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
sizes = gtk_cell_area_box_context_get_requests (context, orientation, for_size, &n_groups);
array = get_array (context, orientation, for_size);
n_expand_groups = count_expand_groups (context);
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
/* First start by naturally allocating space among groups */
avail_size -= (n_groups - 1) * spacing;
for (i = 0; i < n_groups; i++)
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
avail_size -= sizes[i].minimum_size;
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
Available extra space could be less than zero The allocated size, or (horizontally speaking) for-width size, can be smaller than the sum of all minimum widths. For example when the user is resizing tree view columns manually.
2010-11-14 09:43:00 +00:00
if (avail_size > 0)
avail_size = gtk_distribute_natural_allocation (avail_size, n_groups, sizes);
else
avail_size = 0;
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
/* Calculate/distribute expand for groups */
if (n_expand_groups > 0)
{
extra_size = avail_size / n_expand_groups;
extra_extra = avail_size % n_expand_groups;
}
else
extra_size = extra_extra = 0;
allocs = g_new (GtkCellAreaBoxAllocation, n_groups);
for (position = 0, i = 0; i < n_groups; i++)
{
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
allocs[i].group_idx = GPOINTER_TO_INT (sizes[i].data);
Account for the possibility of invisible cells in GtkCellAreaBox/Iter Also changed the GtkCellAreaBox to keep groups in an array instead of a list, for this code it's generally more useful this way (and more optimized).
2010-11-02 07:51:06 +00:00
allocs[i].position = position;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
allocs[i].size = sizes[i].minimum_size;
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
if (group_expands (context, allocs[i].group_idx))
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
{
allocs[i].size += extra_size;
if (extra_extra)
{
allocs[i].size++;
extra_extra--;
}
}
position += allocs[i].size;
position += spacing;
}
Fixed initial bugs in GtkCellArea implementation, starting to render Tested all of this with some scaffolding code, test case comming soon.
2010-11-08 08:43:27 +00:00
if (n_allocs)
*n_allocs = n_groups;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
g_free (sizes);
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
return allocs;
}
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
static void
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
gtk_cell_area_box_context_allocate (GtkCellAreaContext *context,
gint width,
gint height)
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GtkCellAreaBoxContext *box_context = GTK_CELL_AREA_BOX_CONTEXT (context);
GtkCellAreaBoxContextPrivate *priv = box_context->priv;
Make GtkCellAreaBox handle rendering without a previous allocation in the orientation of choice. This is so that treeviews can have some columns oriented vertically and some horizontally, usually the column will only allocate the areas width, having vertical columns without fixed row heights just means it's slower to render.
2010-11-25 07:09:51 +00:00
GtkCellArea *area;
GtkOrientation orientation;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
gint spacing;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
area = gtk_cell_area_context_get_area (context);
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (area));
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
spacing = gtk_cell_area_box_get_spacing (GTK_CELL_AREA_BOX (area));
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Fixing GtkCellAreaBox at render time to consider height-for-width when stacked vertically Also bullet-proofing GtkCellAreaBoxContext at allocate time.
2010-11-26 14:41:39 +00:00
g_free (priv->orientation_allocs);
priv->orientation_allocs = NULL;
priv->n_orientation_allocs = 0;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
if (orientation == GTK_ORIENTATION_HORIZONTAL && width > 0)
Fixing GtkCellAreaBox at render time to consider height-for-width when stacked vertically Also bullet-proofing GtkCellAreaBoxContext at allocate time.
2010-11-26 14:41:39 +00:00
priv->orientation_allocs = allocate_for_orientation (box_context, orientation,
spacing, width, height,
&priv->n_orientation_allocs);
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
else if (orientation == GTK_ORIENTATION_VERTICAL && height > 0)
Fixing GtkCellAreaBox at render time to consider height-for-width when stacked vertically Also bullet-proofing GtkCellAreaBoxContext at allocate time.
2010-11-26 14:41:39 +00:00
priv->orientation_allocs = allocate_for_orientation (box_context, orientation,
spacing, height, width,
&priv->n_orientation_allocs);
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
GTK_CELL_AREA_CONTEXT_CLASS (gtk_cell_area_box_context_parent_class)->allocate (context, width, height);
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
}
Removed gtk_cell_area_context_sum_preferred_width/height apis. Turns out theres not much reason to do this in a separate api, now we just sum up the sizes of aligned cell groups in GtkCellAreaContextBox when pushing the group size.
2010-11-28 09:52:08 +00:00
static void
gtk_cell_area_box_context_sum (GtkCellAreaBoxContext *context,
GtkOrientation orientation)
{
Removed unused variable from GtkCellAreaBoxContext.
2010-12-02 08:09:44 +00:00
GtkCellArea *area;
GtkOrientation box_orientation;
GArray *array;
gint spacing, i;
gint min_size = 0, nat_size = 0;
Removed gtk_cell_area_context_sum_preferred_width/height apis. Turns out theres not much reason to do this in a separate api, now we just sum up the sizes of aligned cell groups in GtkCellAreaContextBox when pushing the group size.
2010-11-28 09:52:08 +00:00
area = gtk_cell_area_context_get_area (GTK_CELL_AREA_CONTEXT (context));
spacing = gtk_cell_area_box_get_spacing (GTK_CELL_AREA_BOX (area));
box_orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (area));
array = get_array (context, orientation, -1);
for (i = 0; i < array->len; i++)
{
Fixed GtkCellAreaBoxContext for some typos introduced while removing GtkCellAreaContext->sum_preferred_width()/height() apis.
2010-12-02 04:19:37 +00:00
CachedSize *size = &g_array_index (array, CachedSize, i);
Removed gtk_cell_area_context_sum_preferred_width/height apis. Turns out theres not much reason to do this in a separate api, now we just sum up the sizes of aligned cell groups in GtkCellAreaContextBox when pushing the group size.
2010-11-28 09:52:08 +00:00
Fixed GtkCellAreaBoxContext for some typos introduced while removing GtkCellAreaContext->sum_preferred_width()/height() apis.
2010-12-02 04:19:37 +00:00
if (box_orientation == orientation)
Removed gtk_cell_area_context_sum_preferred_width/height apis. Turns out theres not much reason to do this in a separate api, now we just sum up the sizes of aligned cell groups in GtkCellAreaContextBox when pushing the group size.
2010-11-28 09:52:08 +00:00
{
/* 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);
}
}
if (orientation == GTK_ORIENTATION_HORIZONTAL)
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);
}
Make GtkCellAreaBox handle rendering without a previous allocation in the orientation of choice. This is so that treeviews can have some columns oriented vertically and some horizontally, usually the column will only allocate the areas width, having vertical columns without fixed row heights just means it's slower to render.
2010-11-25 07:09:51 +00:00
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
/*************************************************************
* API *
*************************************************************/
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
void
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_box_init_groups (GtkCellAreaBoxContext *box_context,
guint n_groups,
gboolean *expand_groups)
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GtkCellAreaBoxContextPrivate *priv;
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (box_context));
Fixed initial bugs in GtkCellArea implementation, starting to render Tested all of this with some scaffolding code, test case comming soon.
2010-11-08 08:43:27 +00:00
g_return_if_fail (n_groups == 0 || expand_groups != NULL);
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
/* When the group dimensions change, all info must be reset
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
* Note this already clears the min/nat values on the CachedSizes
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
*/
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
gtk_cell_area_context_reset (GTK_CELL_AREA_CONTEXT (box_context));
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
priv = box_context->priv;
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
g_array_set_size (priv->base_widths, n_groups);
g_array_set_size (priv->base_heights, n_groups);
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
g_free (priv->expand);
priv->expand = g_memdup (expand_groups, n_groups * sizeof (gboolean));
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
}
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
void
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_box_context_push_group_width (GtkCellAreaBoxContext *box_context,
gint group_idx,
gint minimum_width,
gint natural_width)
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GtkCellAreaBoxContextPrivate *priv;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
CachedSize *size;
Removed gtk_cell_area_context_sum_preferred_width/height apis. Turns out theres not much reason to do this in a separate api, now we just sum up the sizes of aligned cell groups in GtkCellAreaContextBox when pushing the group size.
2010-11-28 09:52:08 +00:00
gboolean grew = FALSE;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (box_context));
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
priv = box_context->priv;
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
g_return_if_fail (group_idx < priv->base_widths->len);
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
size = &g_array_index (priv->base_widths, CachedSize, group_idx);
Removed gtk_cell_area_context_sum_preferred_width/height apis. Turns out theres not much reason to do this in a separate api, now we just sum up the sizes of aligned cell groups in GtkCellAreaContextBox when pushing the group size.
2010-11-28 09:52:08 +00:00
if (minimum_width > size->min_size)
{
size->min_size = minimum_width;
grew = TRUE;
}
if (natural_width > size->nat_size)
{
size->nat_size = natural_width;
grew = TRUE;
}
if (grew)
gtk_cell_area_box_context_sum (box_context, GTK_ORIENTATION_HORIZONTAL);
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
}
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
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)
{
GtkCellAreaBoxContextPrivate *priv;
GArray *group_array;
CachedSize *size;
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (box_context));
priv = box_context->priv;
g_return_if_fail (group_idx < priv->base_widths->len);
group_array = g_hash_table_lookup (priv->heights, GINT_TO_POINTER (for_width));
if (!group_array)
{
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
group_array = group_array_new (box_context);
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
g_hash_table_insert (priv->heights, GINT_TO_POINTER (for_width), group_array);
}
size = &g_array_index (group_array, CachedSize, group_idx);
size->min_size = MAX (size->min_size, minimum_height);
size->nat_size = MAX (size->nat_size, natural_height);
}
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
void
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_box_context_push_group_height (GtkCellAreaBoxContext *box_context,
gint group_idx,
gint minimum_height,
gint natural_height)
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GtkCellAreaBoxContextPrivate *priv;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
CachedSize *size;
Removed gtk_cell_area_context_sum_preferred_width/height apis. Turns out theres not much reason to do this in a separate api, now we just sum up the sizes of aligned cell groups in GtkCellAreaContextBox when pushing the group size.
2010-11-28 09:52:08 +00:00
gboolean grew = FALSE;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (box_context));
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
priv = box_context->priv;
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
g_return_if_fail (group_idx < priv->base_heights->len);
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
size = &g_array_index (priv->base_heights, CachedSize, group_idx);
Removed gtk_cell_area_context_sum_preferred_width/height apis. Turns out theres not much reason to do this in a separate api, now we just sum up the sizes of aligned cell groups in GtkCellAreaContextBox when pushing the group size.
2010-11-28 09:52:08 +00:00
if (minimum_height > size->min_size)
{
size->min_size = minimum_height;
grew = TRUE;
}
if (natural_height > size->nat_size)
{
size->nat_size = natural_height;
grew = TRUE;
}
if (grew)
gtk_cell_area_box_context_sum (box_context, GTK_ORIENTATION_VERTICAL);
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
}
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
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)
{
GtkCellAreaBoxContextPrivate *priv;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
GArray *group_array;
CachedSize *size;
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (box_context));
priv = box_context->priv;
g_return_if_fail (group_idx < priv->base_widths->len);
group_array = g_hash_table_lookup (priv->widths, GINT_TO_POINTER (for_height));
if (!group_array)
{
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
group_array = group_array_new (box_context);
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
g_hash_table_insert (priv->widths, GINT_TO_POINTER (for_height), group_array);
}
size = &g_array_index (group_array, CachedSize, group_idx);
size->min_size = MAX (size->min_size, minimum_width);
size->nat_size = MAX (size->nat_size, natural_width);
}
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
void
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_box_context_get_group_width (GtkCellAreaBoxContext *box_context,
gint group_idx,
gint *minimum_width,
gint *natural_width)
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GtkCellAreaBoxContextPrivate *priv;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
CachedSize *size;
Finished up initial revision of GtkCellAreaBoxIter The interaction between this class and GtkCellAreaBox could use some optimization, maybe the cells and their sizes should be returned as a list and iterated over at the same time as requesting sizes instead of the hash table approach currently taken, however the code is clean this way for now.
2010-10-26 14:01:17 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (box_context));
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
priv = box_context->priv;
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
g_return_if_fail (group_idx < priv->base_widths->len);
Finished up initial revision of GtkCellAreaBoxIter The interaction between this class and GtkCellAreaBox could use some optimization, maybe the cells and their sizes should be returned as a list and iterated over at the same time as requesting sizes instead of the hash table approach currently taken, however the code is clean this way for now.
2010-10-26 14:01:17 +00:00
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
size = &g_array_index (priv->base_widths, CachedSize, group_idx);
Finished up initial revision of GtkCellAreaBoxIter The interaction between this class and GtkCellAreaBox could use some optimization, maybe the cells and their sizes should be returned as a list and iterated over at the same time as requesting sizes instead of the hash table approach currently taken, however the code is clean this way for now.
2010-10-26 14:01:17 +00:00
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
if (minimum_width)
*minimum_width = size->min_size;
if (natural_width)
*natural_width = size->nat_size;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
}
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
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)
{
GtkCellAreaBoxContextPrivate *priv;
GArray *group_array;
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (box_context));
priv = box_context->priv;
g_return_if_fail (group_idx < priv->base_widths->len);
group_array = g_hash_table_lookup (priv->heights, GINT_TO_POINTER (for_width));
if (group_array)
{
CachedSize *size = &g_array_index (group_array, CachedSize, group_idx);
if (minimum_height)
*minimum_height = size->min_size;
if (natural_height)
*natural_height = size->nat_size;
}
else
{
if (minimum_height)
*minimum_height = -1;
if (natural_height)
*natural_height = -1;
}
}
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
void
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_box_context_get_group_height (GtkCellAreaBoxContext *box_context,
gint group_idx,
gint *minimum_height,
gint *natural_height)
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GtkCellAreaBoxContextPrivate *priv;
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
CachedSize *size;
Finished up initial revision of GtkCellAreaBoxIter The interaction between this class and GtkCellAreaBox could use some optimization, maybe the cells and their sizes should be returned as a list and iterated over at the same time as requesting sizes instead of the hash table approach currently taken, however the code is clean this way for now.
2010-10-26 14:01:17 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (box_context));
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
priv = box_context->priv;
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
g_return_if_fail (group_idx < priv->base_heights->len);
Finished up initial revision of GtkCellAreaBoxIter The interaction between this class and GtkCellAreaBox could use some optimization, maybe the cells and their sizes should be returned as a list and iterated over at the same time as requesting sizes instead of the hash table approach currently taken, however the code is clean this way for now.
2010-10-26 14:01:17 +00:00
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
size = &g_array_index (priv->base_heights, CachedSize, group_idx);
Finished up initial revision of GtkCellAreaBoxIter The interaction between this class and GtkCellAreaBox could use some optimization, maybe the cells and their sizes should be returned as a list and iterated over at the same time as requesting sizes instead of the hash table approach currently taken, however the code is clean this way for now.
2010-10-26 14:01:17 +00:00
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
if (minimum_height)
*minimum_height = size->min_size;
if (natural_height)
*natural_height = size->nat_size;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
}
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
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)
{
GtkCellAreaBoxContextPrivate *priv;
GArray *group_array;
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (box_context));
priv = box_context->priv;
g_return_if_fail (group_idx < priv->base_widths->len);
group_array = g_hash_table_lookup (priv->widths, GINT_TO_POINTER (for_height));
if (group_array)
{
CachedSize *size = &g_array_index (group_array, CachedSize, group_idx);
if (minimum_width)
*minimum_width = size->min_size;
if (natural_width)
*natural_width = size->nat_size;
}
else
{
if (minimum_width)
*minimum_width = -1;
if (natural_width)
*natural_width = -1;
}
}
Made GtkCellAreaBox:align-cells a packing property per cell Implemented all request apis on GtkCellAreaBox considering alignment of groups of cells (some cells can be aligned while others fill space smartly).
2010-10-30 08:32:15 +00:00
GtkRequestedSize *
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_box_context_get_widths (GtkCellAreaBoxContext *box_context,
gint *n_widths)
Made GtkCellAreaBox:align-cells a packing property per cell Implemented all request apis on GtkCellAreaBox considering alignment of groups of cells (some cells can be aligned while others fill space smartly).
2010-10-30 08:32:15 +00:00
{
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
return gtk_cell_area_box_context_get_requests (box_context, GTK_ORIENTATION_HORIZONTAL, -1, n_widths);
Made GtkCellAreaBox:align-cells a packing property per cell Implemented all request apis on GtkCellAreaBox considering alignment of groups of cells (some cells can be aligned while others fill space smartly).
2010-10-30 08:32:15 +00:00
}
GtkRequestedSize *
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_box_context_get_heights (GtkCellAreaBoxContext *box_context,
gint *n_heights)
Made GtkCellAreaBox:align-cells a packing property per cell Implemented all request apis on GtkCellAreaBox considering alignment of groups of cells (some cells can be aligned while others fill space smartly).
2010-10-30 08:32:15 +00:00
{
Finally really support rendering of cells in an unallocated context. What this means is basically that a vertically oriented GtkCellAreaBox will render cells properly even if the height is not constant for every for of data in the said GtkCellAreaContext (i.e. the height was not allocated by gtk_cell_area_context_allocate). This is done completely on the fly and so is much more heavy duty at render time (considerably slower but not visibly noticable in lightweight views like GtkTreeMenu). Note that cell alignments are not possible in an unallocated orientation, each row of data individually receives only enough space to render the independant row and no space is reserved for alignments if the size is not a constant size across rows in the same context.
2010-11-26 12:26:24 +00:00
return gtk_cell_area_box_context_get_requests (box_context, GTK_ORIENTATION_VERTICAL, -1, n_heights);
Made GtkCellAreaBox:align-cells a packing property per cell Implemented all request apis on GtkCellAreaBox considering alignment of groups of cells (some cells can be aligned while others fill space smartly).
2010-10-30 08:32:15 +00:00
}
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
Make GtkCellAreaBox handle rendering without a previous allocation in the orientation of choice. This is so that treeviews can have some columns oriented vertically and some horizontally, usually the column will only allocate the areas width, having vertical columns without fixed row heights just means it's slower to render.
2010-11-25 07:09:51 +00:00
GtkCellAreaBoxAllocation *
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_box_context_get_orientation_allocs (GtkCellAreaBoxContext *context,
gint *n_allocs)
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
{
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GtkCellAreaBoxContextPrivate *priv;
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
g_return_val_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (context), NULL);
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
priv = context->priv;
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
*n_allocs = priv->n_orientation_allocs;
return priv->orientation_allocs;
}
Reference in New Issue Copy Permalink