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

855 lines
29 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
Change FSF Address
2012-02-27 13:01:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
*/
#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"
gtk: Rename private header to private name gtk/gtkcellareaboxcontext.h -> gtk/gtkcellareaboxcontextprivate.h
2011-01-11 15:04:00 +00:00
#include "gtkcellareaboxcontextprivate.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 */
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +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 */
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
static void _gtk_cell_area_box_context_reset (GtkCellAreaContext *context);
static void _gtk_cell_area_box_context_get_preferred_height_for_width (GtkCellAreaContext *context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int width,
int *minimum_height,
int *natural_height);
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
static void _gtk_cell_area_box_context_get_preferred_width_for_height (GtkCellAreaContext *context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int height,
int *minimum_width,
int *natural_width);
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
/* Internal functions */
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
static void _gtk_cell_area_box_context_sum (GtkCellAreaBoxContext *context,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkOrientation orientation,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int for_size,
int *minimum_size,
int *natural_size);
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,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkOrientation orientation,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int for_size);
Changed all the flush apis on GtkCellAreaContext for a single "reset" api.
2010-11-27 07:05:14 +00:00
static gboolean group_expands (GtkCellAreaBoxContext *context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int group_idx);
static int 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 {
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int min_size;
int nat_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
} 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;
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
/* Whether each group is aligned */
gboolean *align;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
};
gtk: Use new macros for defining private data https://bugzilla.gnome.org/show_bug.cgi?id=702996
2013-06-27 19:02:52 +00:00
G_DEFINE_TYPE_WITH_PRIVATE (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,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkOrientation orientation,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int for_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
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
GArray *array;
if (for_size < 0)
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
array = priv->base_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
else
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
array = priv->base_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
}
else
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
array = g_hash_table_lookup (priv->widths, GINT_TO_POINTER (for_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
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
if (!array)
array = priv->base_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
else
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
array = g_hash_table_lookup (priv->heights, GINT_TO_POINTER (for_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
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
if (!array)
array = priv->base_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
}
return array;
}
static gboolean
group_expands (GtkCellAreaBoxContext *context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int group_idx)
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
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
g_assert (group_idx >= 0 && group_idx < priv->base_widths->len);
return priv->expand[group_idx];
}
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
static int
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
count_expand_groups (GtkCellAreaBoxContext *context)
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int i, expand = 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
for (i = 0; i < priv->base_widths->len; i++)
{
if (priv->expand[i])
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
expand++;
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 expand;
}
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
static void
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +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
gtk: Use new macros for defining private data https://bugzilla.gnome.org/show_bug.cgi?id=702996
2013-06-27 19:02:52 +00:00
box_context->priv = _gtk_cell_area_box_context_get_instance_private (box_context);
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
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,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
NULL, (GDestroyNotify)free_cache_array);
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->heights = g_hash_table_new_full (g_direct_hash, g_direct_equal,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
NULL, (GDestroyNotify)free_cache_array);
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
}
static void
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +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 */
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +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
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
context_class->reset = _gtk_cell_area_box_context_reset;
context_class->get_preferred_height_for_width = _gtk_cell_area_box_context_get_preferred_height_for_width;
context_class->get_preferred_width_for_height = _gtk_cell_area_box_context_get_preferred_width_for_height;
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
}
/*************************************************************
* GObjectClass *
*************************************************************/
static void
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +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
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 "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
g_free (priv->align);
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +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
}
/*************************************************************
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +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
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +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;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int 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
GTK_CELL_AREA_CONTEXT_CLASS
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
(_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
}
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: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_sum (GtkCellAreaBoxContext *context,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkOrientation orientation,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int for_size,
int *minimum_size,
int *natural_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
{
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
GtkCellAreaBoxContextPrivate *priv = context->priv;
GtkCellAreaBox *area;
Removed unused variable from GtkCellAreaBoxContext.
2010-12-02 08:09:44 +00:00
GtkOrientation box_orientation;
GArray *array;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int spacing, i, last_aligned_group_idx;
int 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
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
area = (GtkCellAreaBox *)gtk_cell_area_context_get_area (GTK_CELL_AREA_CONTEXT (context));
spacing = gtk_cell_area_box_get_spacing (area);
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
box_orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (area));
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
array = get_array (context, orientation, for_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
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
/* Get the last visible aligned group
* (we need to get space at least up till this group) */
for (i = array->len - 1; i >= 0; i--)
{
if (priv->align[i] &&
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
_gtk_cell_area_box_group_visible (area, i))
break;
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
}
last_aligned_group_idx = i >= 0 ? i : 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
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)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
if (i > last_aligned_group_idx &&
!_gtk_cell_area_box_group_visible (area, i))
continue;
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +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;
}
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
else
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
min_size = MAX (min_size, size->min_size);
nat_size = MAX (nat_size, size->nat_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
}
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
if (for_size < 0)
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gtk_cell_area_context_push_preferred_width (GTK_CELL_AREA_CONTEXT (context), min_size, nat_size);
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
else
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gtk_cell_area_context_push_preferred_height (GTK_CELL_AREA_CONTEXT (context), min_size, nat_size);
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
}
if (minimum_size)
*minimum_size = min_size;
if (natural_size)
*natural_size = nat_size;
}
static void
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_get_preferred_height_for_width (GtkCellAreaContext *context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int width,
int *minimum_height,
int *natural_height)
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
{
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_sum (GTK_CELL_AREA_BOX_CONTEXT (context), GTK_ORIENTATION_VERTICAL,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
width, minimum_height, natural_height);
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
}
static void
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_get_preferred_width_for_height (GtkCellAreaContext *context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int height,
int *minimum_width,
int *natural_width)
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
{
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_sum (GTK_CELL_AREA_BOX_CONTEXT (context), GTK_ORIENTATION_HORIZONTAL,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
height, minimum_width, natural_width);
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
}
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 *
*************************************************************/
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
static void
copy_size_array (GArray *src_array,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GArray *dest_array)
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
{
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int i;
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
for (i = 0; i < src_array->len; i++)
{
CachedSize *src = &g_array_index (src_array, CachedSize, i);
CachedSize *dest = &g_array_index (dest_array, CachedSize, i);
memcpy (dest, src, sizeof (CachedSize));
}
}
static void
for_size_copy (gpointer key,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GArray *size_array,
GHashTable *dest_hash)
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
{
GArray *new_array;
new_array = g_array_new (FALSE, TRUE, sizeof (CachedSize));
g_array_set_size (new_array, size_array->len);
copy_size_array (size_array, new_array);
g_hash_table_insert (dest_hash, key, new_array);
}
GtkCellAreaBoxContext *
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_copy (GtkCellAreaBox *box,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaBoxContext *context)
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
{
Fixed gtk_cell_area_box_context_copy() to also copy it's allocations.
2010-12-13 06:37:12 +00:00
GtkCellAreaBoxContext *copy;
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
copy = g_object_new (GTK_TYPE_CELL_AREA_BOX_CONTEXT,
"area", box, NULL);
Fixed gtk_cell_area_box_context_copy() to also copy it's allocations.
2010-12-13 06:37:12 +00:00
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
_gtk_cell_area_box_init_groups (copy,
context->priv->base_widths->len,
context->priv->expand,
context->priv->align);
Fixed gtk_cell_area_box_context_copy() to also copy it's allocations.
2010-12-13 06:37:12 +00:00
/* Copy the base arrays */
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
copy_size_array (context->priv->base_widths,
copy->priv->base_widths);
copy_size_array (context->priv->base_heights,
copy->priv->base_heights);
Fixed gtk_cell_area_box_context_copy() to also copy it's allocations.
2010-12-13 06:37:12 +00:00
/* Copy each for size */
g_hash_table_foreach (context->priv->heights,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
(GHFunc)for_size_copy, copy->priv->heights);
Fixed gtk_cell_area_box_context_copy() to also copy it's allocations.
2010-12-13 06:37:12 +00:00
g_hash_table_foreach (context->priv->widths,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
(GHFunc)for_size_copy, copy->priv->widths);
Fixed gtk_cell_area_box_context_copy() to also copy it's allocations.
2010-12-13 06:37:12 +00:00
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
Fixed an error in my last commit in gtk_cell_area_box_context_copy().
2010-12-13 07:27:36 +00:00
return copy;
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
}
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
void
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
_gtk_cell_area_box_init_groups (GtkCellAreaBoxContext *box_context,
guint n_groups,
gboolean *expand_groups,
gboolean *align_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
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +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));
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
g_free (priv->align);
priv->align = g_memdup (align_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
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_push_group_width (GtkCellAreaBoxContext *box_context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int group_idx,
int minimum_width,
int 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: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_sum (box_context, GTK_ORIENTATION_HORIZONTAL, -1, NULL, NULL);
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: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_push_group_height_for_width (GtkCellAreaBoxContext *box_context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int group_idx,
int for_width,
int minimum_height,
int natural_height)
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
{
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
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_push_group_height (GtkCellAreaBoxContext *box_context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int group_idx,
int minimum_height,
int 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: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_sum (box_context, GTK_ORIENTATION_VERTICAL, -1, NULL, NULL);
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: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_push_group_width_for_height (GtkCellAreaBoxContext *box_context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int group_idx,
int for_height,
int minimum_width,
int natural_width)
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04: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
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
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_get_group_width (GtkCellAreaBoxContext *box_context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int group_idx,
int *minimum_width,
int *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;
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
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: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_get_group_height_for_width (GtkCellAreaBoxContext *box_context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int group_idx,
int for_width,
int *minimum_height,
int *natural_height)
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
{
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)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
*minimum_height = size->min_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
if (natural_height)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
*natural_height = size->nat_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
}
else
{
if (minimum_height)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
*minimum_height = -1;
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
if (natural_height)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
*natural_height = -1;
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
}
}
Added GtkCellAreaBox subclass to handle alignments of cells across rows inside a GtkCellAreaBox.
2010-10-26 09:22:59 +00:00
void
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_get_group_height (GtkCellAreaBoxContext *box_context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int group_idx,
int *minimum_height,
int *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;
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
Cleaned up GtkCellAreaIter implementation to use arrays to store grouped cell information.
2010-10-31 04:06:10 +00:00
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: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_get_group_width_for_height (GtkCellAreaBoxContext *box_context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int group_idx,
int for_height,
int *minimum_width,
int *natural_width)
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
{
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)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
*minimum_width = size->min_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
if (natural_width)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
*natural_width = size->nat_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
}
else
{
if (minimum_width)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
*minimum_width = -1;
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
if (natural_width)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
*natural_width = -1;
Revert "Removed tons of api that we dont absolutely need in GtkCellAreaContext:" This reverts commit 5f7787ab2ead2cdd11ebe17b16dd9498daaaf9c5.
2010-11-26 04:23:01 +00:00
}
}
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
static GtkRequestedSize *
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_get_requests (GtkCellAreaBoxContext *box_context,
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
GtkCellAreaBox *area,
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
GtkOrientation orientation,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int for_size,
int *n_requests)
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
{
GtkCellAreaBoxContextPrivate *priv = box_context->priv;
GtkRequestedSize *requests;
GArray *array;
CachedSize *size;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int visible_groups = 0;
int last_aligned_group_idx = 0;
int i, j;
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
/* Get the last visible aligned group
* (we need to get space at least up till this group) */
for (i = priv->base_widths->len - 1; i >= 0; i--)
{
if (priv->align[i] &&
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
_gtk_cell_area_box_group_visible (area, i))
break;
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
}
last_aligned_group_idx = i >= 0 ? i : 0;
priv = box_context->priv;
array = get_array (box_context, orientation, for_size);
for (i = 0; i < array->len; i++)
{
size = &g_array_index (array, CachedSize, i);
if (size->nat_size > 0 &&
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
(i <= last_aligned_group_idx ||
_gtk_cell_area_box_group_visible (area, i)))
visible_groups++;
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
}
requests = g_new (GtkRequestedSize, visible_groups);
for (j = 0, i = 0; i < array->len; i++)
{
size = &g_array_index (array, CachedSize, i);
if (size->nat_size > 0 &&
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
(i <= last_aligned_group_idx ||
_gtk_cell_area_box_group_visible (area, i)))
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
{
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;
}
static GtkCellAreaBoxAllocation *
allocate_for_orientation (GtkCellAreaBoxContext *context,
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
GtkCellAreaBox *area,
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
GtkOrientation orientation,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int spacing,
int size,
int for_size,
int *n_allocs)
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
GtkCellAreaBoxAllocation *allocs;
GtkRequestedSize *sizes;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int n_expand_groups = 0;
int i, n_groups, position, vis_position;
int extra_size, extra_extra;
int avail_size = size;
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
sizes = _gtk_cell_area_box_context_get_requests (context, area, orientation, for_size, &n_groups);
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
n_expand_groups = count_expand_groups (context);
/* First start by naturally allocating space among groups */
avail_size -= (n_groups - 1) * spacing;
for (i = 0; i < n_groups; i++)
avail_size -= sizes[i].minimum_size;
if (avail_size > 0)
avail_size = gtk_distribute_natural_allocation (avail_size, n_groups, sizes);
else
avail_size = 0;
/* 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 (vis_position = 0, position = 0, i = 0; i < n_groups; i++)
{
allocs[i].group_idx = GPOINTER_TO_INT (sizes[i].data);
if (priv->align[allocs[i].group_idx])
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
vis_position = position;
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
allocs[i].position = vis_position;
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--;
}
}
position += allocs[i].size;
position += spacing;
if (_gtk_cell_area_box_group_visible (area, allocs[i].group_idx))
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
{
vis_position += allocs[i].size;
vis_position += spacing;
}
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
}
if (n_allocs)
*n_allocs = n_groups;
g_free (sizes);
return allocs;
}
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 *
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_get_widths (GtkCellAreaBoxContext *box_context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int *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
{
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
GtkCellAreaBox *area = (GtkCellAreaBox *)gtk_cell_area_context_get_area (GTK_CELL_AREA_CONTEXT (box_context));
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
return _gtk_cell_area_box_context_get_requests (box_context, area, 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 *
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_get_heights (GtkCellAreaBoxContext *box_context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int *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 "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
GtkCellAreaBox *area = (GtkCellAreaBox *)gtk_cell_area_context_get_area (GTK_CELL_AREA_CONTEXT (box_context));
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
return _gtk_cell_area_box_context_get_requests (box_context, area, 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 *
gtk: Prefix GtkCellAreaBoxContext symbols with an underscore They are private.
2011-01-11 15:40:35 +00:00
_gtk_cell_area_box_context_get_orientation_allocs (GtkCellAreaBoxContext *context,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int *n_allocs)
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
{
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
GtkCellAreaContext *ctx = GTK_CELL_AREA_CONTEXT (context);
GtkCellAreaBox *area;
GtkOrientation orientation;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int spacing, width, height, alloc_count = 0;
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
GtkCellAreaBoxAllocation *allocs = NULL;
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
area = (GtkCellAreaBox *)gtk_cell_area_context_get_area (ctx);
orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (area));
spacing = gtk_cell_area_box_get_spacing (area);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
gtk_cell_area_context_get_allocation (ctx, &width, &height);
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
if (orientation == GTK_ORIENTATION_HORIZONTAL && width > 0)
allocs = allocate_for_orientation (context, area, orientation,
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
spacing, width, height,
&alloc_count);
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
else if (orientation == GTK_ORIENTATION_VERTICAL && height > 0)
allocs = allocate_for_orientation (context, area, orientation,
Don't export gtk_cell_area_box_init_groups That function can't be meant to be public, since it take a GtkCellAreaBoxContext argument, which is not a public type.
2011-02-09 04:18:22 +00:00
spacing, height, width,
&alloc_count);
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
*n_allocs = alloc_count;
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
Added "fixed-size" cell property to GtkCellAreaBox Now a cell can either have a "fixed" size or it can have an "aligned" starting point or both. "fixed" size cells take no space when they are invisible.
2010-12-21 12:11:01 +00:00
return allocs;
Added the majority of the allocate machinery to GtkCellAreaIter[Box].
2010-10-30 14:06:26 +00:00
}
Reference in New Issue Copy Permalink