AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
75c75e001c
gtk2/gtk/gtksizerequest.c

751 lines
27 KiB
C
Raw Normal View History

Mass api change from GtkExtendedLayout --> GtkSizeRequest This commit makes a few massive changes to the extended layout code: a.) gtkextendedlayout.c --> gtksizerequest.c b.) _is_height_for_width --> get_request_mode() c.) get_desired_size(), get_desired_width(), get_desired_height() --> get_size(), get_width(), get_height() This is the first partial commit and only effects portions of the tree that have already been merged in master (in order to easily cherry pick this commit). Conflicts: gtk/Makefile.am gtk/gtk.h gtk/gtk.symbols gtk/gtkextendedlayout.h
2010-06-18 04:11:26 +00:00
/* gtksizerequest.c
Slightly reduced extended layout cache size, updated authors/copywrite year.
2010-04-20 22:53:54 +00:00
* Copyright (C) 2007-2010 Openismus GmbH
native-layout: Introduce GtkExtendedLayout interface.
2009-12-02 08:48:42 +00:00
*
Slightly reduced extended layout cache size, updated authors/copywrite year.
2010-04-20 22:53:54 +00:00
* Authors:
native-layout: Introduce GtkExtendedLayout interface.
2009-12-02 08:48:42 +00:00
* Mathias Hasselmann <mathias@openismus.com>
Slightly reduced extended layout cache size, updated authors/copywrite year.
2010-04-20 22:53:54 +00:00
* Tristan Van Berkom <tristan.van.berkom@gmail.com>
native-layout: Introduce GtkExtendedLayout interface.
2009-12-02 08:48:42 +00:00
*
* 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/>.
native-layout: Introduce GtkExtendedLayout interface.
2009-12-02 08:48:42 +00:00
*/
#include <config.h>
Split off gtkprivate.h The gtkprivate.h header contains GtkWidget-specific private symbols that are not useful except in a handful of cases. Basically everything includes gtkprivate.h for the GTK_PARAM_* macros. https://bugzilla.gnome.org/show_bug.cgi?id=632539
2010-10-19 17:14:46 +00:00
Mass api change from GtkExtendedLayout --> GtkSizeRequest This commit makes a few massive changes to the extended layout code: a.) gtkextendedlayout.c --> gtksizerequest.c b.) _is_height_for_width --> get_request_mode() c.) get_desired_size(), get_desired_width(), get_desired_height() --> get_size(), get_width(), get_height() This is the first partial commit and only effects portions of the tree that have already been merged in master (in order to easily cherry pick this commit). Conflicts: gtk/Makefile.am gtk/gtk.h gtk/gtk.symbols gtk/gtkextendedlayout.h
2010-06-18 04:11:26 +00:00
#include "gtksizerequest.h"
Split off gtkprivate.h The gtkprivate.h header contains GtkWidget-specific private symbols that are not useful except in a handful of cases. Basically everything includes gtkprivate.h for the GTK_PARAM_* macros. https://bugzilla.gnome.org/show_bug.cgi?id=632539
2010-10-19 17:14:46 +00:00
Remove GtkObject completely
2010-09-18 23:57:32 +00:00
#include "gtkdebug.h"
native-layout: Introduce GtkExtendedLayout interface.
2009-12-02 08:48:42 +00:00
#include "gtkintl.h"
Split off gtkprivate.h The gtkprivate.h header contains GtkWidget-specific private symbols that are not useful except in a handful of cases. Basically everything includes gtkprivate.h for the GTK_PARAM_* macros. https://bugzilla.gnome.org/show_bug.cgi?id=632539
2010-10-19 17:14:46 +00:00
#include "gtkprivate.h"
#include "gtksizegroup-private.h"
sizerequest: Split out size request cache code into separate header
2012-11-13 12:41:05 +00:00
#include "gtksizerequestcacheprivate.h"
Split off gtkprivate.h The gtkprivate.h header contains GtkWidget-specific private symbols that are not useful except in a handful of cases. Basically everything includes gtkprivate.h for the GTK_PARAM_* macros. https://bugzilla.gnome.org/show_bug.cgi?id=632539
2010-10-19 17:14:46 +00:00
#include "gtkwidgetprivate.h"
sizerequest: Honor css min size
2017-05-03 17:23:35 +00:00
#include "gtkcssnodeprivate.h"
#include "gtkcssnumbervalueprivate.h"
Hook GtkLayoutManager into GtkWidget We delegate the size request mode, the measuring, and the allocation of a widget through a GtkLayoutManager instance, if one has been attached to the widget; otherwise, we fall back to the widget's own implementation.
2018-12-12 17:20:28 +00:00
#include "gtklayoutmanagerprivate.h"
native-layout: Introduce GtkExtendedLayout interface.
2009-12-02 08:48:42 +00:00
Reduce memory consumption of the size request cache. This patch makes contextual height-for-width request caching optional (the contextual cache is not allocated for widgets that report GTK_SIZE_REQUEST_CONSTANT_SIZE).
2011-03-05 10:29:10 +00:00
size request: Redo the recursion checks Use G_ENABLE_CONSISTENCY checks for the recursion checks in gtksizerequest.c
2015-09-09 01:06:38 +00:00
#ifdef G_ENABLE_CONSISTENCY_CHECKS
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
static GQuark recursion_check_quark = 0;
static void
push_recursion_check (GtkWidget *widget,
sizerequest: Remove for_size parameter from push_recursion_check It's not needed anymore after also fixing the warning message to not mention the old get_preferred* functions.
2017-05-18 07:43:32 +00:00
GtkOrientation orientation)
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
{
sizerequest: Remove for_size parameter from push_recursion_check It's not needed anymore after also fixing the warning message to not mention the old get_preferred* functions.
2017-05-18 07:43:32 +00:00
gboolean in_measure = FALSE;
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
if (recursion_check_quark == 0)
recursion_check_quark = g_quark_from_static_string ("gtk-size-request-in-progress");
sizerequest: Remove for_size parameter from push_recursion_check It's not needed anymore after also fixing the warning message to not mention the old get_preferred* functions.
2017-05-18 07:43:32 +00:00
in_measure = GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (widget), recursion_check_quark));
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
sizerequest: Remove for_size parameter from push_recursion_check It's not needed anymore after also fixing the warning message to not mention the old get_preferred* functions.
2017-05-18 07:43:32 +00:00
if (in_measure)
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
{
sizerequest: Remove for_size parameter from push_recursion_check It's not needed anymore after also fixing the warning message to not mention the old get_preferred* functions.
2017-05-18 07:43:32 +00:00
g_warning ("%s %p: widget tried to gtk_widget_measure inside "
" GtkWidget::measure implementation. "
"Should just invoke GTK_WIDGET_GET_CLASS(widget)->measure "
"directly rather than using gtk_widget_measure",
G_OBJECT_TYPE_NAME (widget), widget);
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
}
sizerequest: Remove for_size parameter from push_recursion_check It's not needed anymore after also fixing the warning message to not mention the old get_preferred* functions.
2017-05-18 07:43:32 +00:00
g_object_set_qdata (G_OBJECT (widget), recursion_check_quark, GINT_TO_POINTER(TRUE));
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
}
static void
pop_recursion_check (GtkWidget *widget,
sizerequest: Use GtkOrientation ... instead of GtkSizeGroupMode. Orientation is what we're interested in after all. When we need a GtkSizeGroupMode, we can do the translation where we need it.
2012-11-14 00:25:21 +00:00
GtkOrientation orientation)
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
{
g_object_set_qdata (G_OBJECT (widget), recursion_check_quark, NULL);
}
size request: Redo the recursion checks Use G_ENABLE_CONSISTENCY checks for the recursion checks in gtksizerequest.c
2015-09-09 01:06:38 +00:00
#else
sizerequest: Remove for_size parameter from push_recursion_check It's not needed anymore after also fixing the warning message to not mention the old get_preferred* functions.
2017-05-18 07:43:32 +00:00
#define push_recursion_check(widget, orientation)
size request: Redo the recursion checks Use G_ENABLE_CONSISTENCY checks for the recursion checks in gtksizerequest.c
2015-09-09 01:06:38 +00:00
#define pop_recursion_check(widget, orientation)
#endif /* G_ENABLE_CONSISTENCY_CHECKS */
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
sizerequest: Fix request mode for layout managers We can't just call GtkWidgetClass::get_request_mode() anymore. If the widget has a layout manager, we need to ask that one.
2019-05-25 07:03:37 +00:00
static GtkSizeRequestMode
fetch_request_mode (GtkWidget *widget)
{
GtkLayoutManager *layout_manager = gtk_widget_get_layout_manager (widget);
if (layout_manager != NULL)
return gtk_layout_manager_get_request_mode (layout_manager);
else
return GTK_WIDGET_GET_CLASS (widget)->get_request_mode (widget);
}
sizerequest: Honor css min size
2017-05-03 17:23:35 +00:00
static gint
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
get_number (GtkCssValue *value)
sizerequest: Honor css min size
2017-05-03 17:23:35 +00:00
{
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
double d = _gtk_css_number_value_get (value, 100);
sizerequest: Honor css min size
2017-05-03 17:23:35 +00:00
if (d < 1)
return ceil (d);
else
return floor (d);
}
SizeRequest: Round px values up for min CSS sizes Otherwise, requesting a min size in em where the equivalent in px had a fractional part would lead to the widget getting allocated 1 too few px. You could see this in the CSS property vs. allocation in the Inspector. Note that margin/border/padding are left alone: the rationale is that we do as browsers do, and Benjamin said we already do that for those, whereas his tests on min-(width|height) showed otherwise. My subsequent analysis indicated it to be far less clear-cut than that, but he remains unconvinced that we should ceil() all the things! So just do these ones. https://gitlab.gnome.org/GNOME/gtk/issues/1088
2018-05-21 20:45:27 +00:00
/* Special-case min-width|height to round upwards, to avoid underalloc by 1px */
static int
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
get_number_ceil (GtkCssValue *value)
SizeRequest: Round px values up for min CSS sizes Otherwise, requesting a min size in em where the equivalent in px had a fractional part would lead to the widget getting allocated 1 too few px. You could see this in the CSS property vs. allocation in the Inspector. Note that margin/border/padding are left alone: the rationale is that we do as browsers do, and Benjamin said we already do that for those, whereas his tests on min-(width|height) showed otherwise. My subsequent analysis indicated it to be far less clear-cut than that, but he remains unconvinced that we should ceil() all the things! So just do these ones. https://gitlab.gnome.org/GNOME/gtk/issues/1088
2018-05-21 20:45:27 +00:00
{
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
return ceil (_gtk_css_number_value_get (value, 100));
SizeRequest: Round px values up for min CSS sizes Otherwise, requesting a min size in em where the equivalent in px had a fractional part would lead to the widget getting allocated 1 too few px. You could see this in the CSS property vs. allocation in the Inspector. Note that margin/border/padding are left alone: the rationale is that we do as browsers do, and Benjamin said we already do that for those, whereas his tests on min-(width|height) showed otherwise. My subsequent analysis indicated it to be far less clear-cut than that, but he remains unconvinced that we should ceil() all the things! So just do these ones. https://gitlab.gnome.org/GNOME/gtk/issues/1088
2018-05-21 20:45:27 +00:00
}
sizerequest: Honor css min size
2017-05-03 17:23:35 +00:00
static void
get_box_margin (GtkCssStyle *style,
GtkBorder *margin)
{
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
margin->top = get_number (style->size->margin_top);
margin->left = get_number (style->size->margin_left);
margin->bottom = get_number (style->size->margin_bottom);
margin->right = get_number (style->size->margin_right);
sizerequest: Honor css min size
2017-05-03 17:23:35 +00:00
}
static void
get_box_border (GtkCssStyle *style,
GtkBorder *border)
{
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
border->top = get_number (style->border->border_top_width);
border->left = get_number (style->border->border_left_width);
border->bottom = get_number (style->border->border_bottom_width);
border->right = get_number (style->border->border_right_width);
sizerequest: Honor css min size
2017-05-03 17:23:35 +00:00
}
static void
get_box_padding (GtkCssStyle *style,
GtkBorder *border)
{
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
border->top = get_number (style->size->padding_top);
border->left = get_number (style->size->padding_left);
border->bottom = get_number (style->size->padding_bottom);
border->right = get_number (style->size->padding_right);
sizerequest: Honor css min size
2017-05-03 17:23:35 +00:00
}
sizerequest: Move sizegroups function to different source file
2012-11-04 15:02:14 +00:00
static void
sizerequest: Restructure code Make the compute_size_request() function take into account size groups itself instead of doing a weird "bump_requisition" call.
2012-11-04 15:10:20 +00:00
gtk_widget_query_size_for_orientation (GtkWidget *widget,
sizerequest: Use GtkOrientation ... instead of GtkSizeGroupMode. Orientation is what we're interested in after all. When we need a GtkSizeGroupMode, we can do the translation where we need it.
2012-11-14 00:25:21 +00:00
GtkOrientation orientation,
sizerequest: Restructure code Make the compute_size_request() function take into account size groups itself instead of doing a weird "bump_requisition" call.
2012-11-04 15:10:20 +00:00
gint for_size,
sizerequest: Stop checking orientation in query_size_for_orientation Since we have ->measure now, we can implement this code more elegantly.
2017-05-18 08:11:54 +00:00
gint *minimum,
gint *natural,
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
gint *minimum_baseline,
gint *natural_baseline)
sizerequest: Move sizegroups function to different source file
2012-11-04 15:02:14 +00:00
{
sizerequest: Only check reported baselines if requested If the passed-in store locations for the baselines are NULL anyway, we don't need to check the reported baselines for correctness.
2018-07-15 15:56:11 +00:00
const gboolean baselines_requested = (minimum_baseline != NULL || natural_baseline != NULL);
sizerequestcache: Move lookup function ...and clean up its API.
2012-11-14 00:10:21 +00:00
SizeRequestCache *cache;
gint min_size = 0;
gint nat_size = 0;
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
gint min_baseline = -1;
gint nat_baseline = -1;
sizerequestcache: Move lookup function ...and clean up its API.
2012-11-14 00:10:21 +00:00
gboolean found_in_cache;
Some doc and formatting tweaks
2010-04-28 14:04:21 +00:00
widget: Add a resize_needed flag ... and API to set and unset it. It is set when gtk_widget_queue_resize() is called. It is unset when gtk_widget_get_preferred_width/height() is called. So far it is not used.
2015-09-28 00:19:25 +00:00
gtk_widget_ensure_resize (widget);
sizerequest: Directly query new request_mode We are already inside the function that populates the size request cache, so do it here instead of implicitly in get_request_mode.
2018-12-02 08:54:25 +00:00
/* We check the request mode first, to determine whether the widget even does
* any wfh/hfw handling. If it doesn't, we reset for_size to -1 and ensure
* that we only cache one size for the widget (i.e. a lot more cache hits). */
cache = _gtk_widget_peek_request_cache (widget);
if (G_UNLIKELY (!cache->request_mode_valid))
{
sizerequest: Fix request mode for layout managers We can't just call GtkWidgetClass::get_request_mode() anymore. If the widget has a layout manager, we need to ask that one.
2019-05-25 07:03:37 +00:00
cache->request_mode = fetch_request_mode (widget);
sizerequest: Directly query new request_mode We are already inside the function that populates the size request cache, so do it here instead of implicitly in get_request_mode.
2018-12-02 08:54:25 +00:00
cache->request_mode_valid = TRUE;
}
if (cache->request_mode == GTK_SIZE_REQUEST_CONSTANT_SIZE)
sizerequest: Optimize CONSTANT_SIZE better We can set for_size to -1 earlier than we did. Doing so makes sure we only cache one value (as we should in the first place). In GTK 3.6, this worked properly, but with Previously, this check was moved further up to avoid interacting with size groups. But after recent refactorings, size groups are handled way earlier anyway.
2012-11-14 13:03:47 +00:00
for_size = -1;
sizerequestcache: Move lookup function ...and clean up its API.
2012-11-14 00:10:21 +00:00
found_in_cache = _gtk_size_request_cache_lookup (cache,
orientation,
for_size,
&min_size,
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
&nat_size,
sizerequest: Move css handling to gtk_widget_measure We need to adjust the passed for_size to fit into the content allocation of the widget. That also means that we can't call gtk_widget_measure(widget) inside gtk_widget_measure(widget) since now the for_size will be adjusted twice.
2017-05-06 08:02:03 +00:00
&min_baseline,
&nat_baseline);
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
Fixed GtkExtendedLayout interaction with sizegroups plus cleanups Fixed GtkExtendedLayout to interact with sizegroups, "size-requsts" and caching the values all in the same code segment. Migrated the cache code to be internal to gtkextendedlayout.c
2010-04-17 05:51:10 +00:00
if (!found_in_cache)
{
sizerequest: Pull locals in closest scope
2018-04-21 07:14:48 +00:00
GtkWidgetClass *widget_class;
GtkCssStyle *style;
GtkBorder margin, border, padding;
sizerequest: Fix min size with widget margins
2017-05-18 10:16:35 +00:00
int adjusted_min, adjusted_natural;
Fix baselines wrt css values The reported minimum baseline is for the reported min height, but if the css min-height is greater than that, we need to account for that fact when saving the baseline. Since the reported baseline is relative to the widget's origin, we also need to add the top values for margin, border and padding to the reported baseline.
2017-06-27 11:27:58 +00:00
int reported_min_size = 0;
int reported_nat_size = 0;
sizerequest: Pull locals in closest scope
2018-04-21 07:14:48 +00:00
int css_min_size;
int css_min_for_size;
int css_extra_for_size;
int css_extra_size;
sizerequest: Stop clamping for_size to natural size Widgets should be given the actual size they will be allocated, so they can do something with it. If they want to clamp themselves to their natural size, nothing's stopping them, they know their natural size after all.
2020-02-22 04:23:41 +00:00
int widget_margins_for_size;
sizerequest: Fix min size with widget margins
2017-05-18 10:16:35 +00:00
style = gtk_css_node_get_style (gtk_widget_get_css_node (widget));
get_box_margin (style, &margin);
get_box_border (style, &border);
get_box_padding (style, &padding);
sizerequest: Pull locals in closest scope
2018-04-21 07:14:48 +00:00
widget_class = GTK_WIDGET_GET_CLASS (widget);
sizerequest: Fix min size with widget margins
2017-05-18 10:16:35 +00:00
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
css_extra_size = margin.left + margin.right + border.left + border.right + padding.left + padding.right;
css_extra_for_size = margin.top + margin.bottom + border.top + border.bottom + padding.top + padding.bottom;
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
css_min_size = get_number_ceil (style->size->min_width);
css_min_for_size = get_number_ceil (style->size->min_height);
sizerequest: Stop clamping for_size to natural size Widgets should be given the actual size they will be allocated, so they can do something with it. If they want to clamp themselves to their natural size, nothing's stopping them, they know their natural size after all.
2020-02-22 04:23:41 +00:00
widget_margins_for_size = widget->priv->margin.top + widget->priv->margin.bottom;
sizerequest: Fix min size with widget margins
2017-05-18 10:16:35 +00:00
}
else
{
css_extra_size = margin.top + margin.bottom + border.top + border.bottom + padding.top + padding.bottom;
css_extra_for_size = margin.left + margin.right + border.left + border.right + padding.left + padding.right;
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
css_min_size = get_number_ceil (style->size->min_height);
css_min_for_size = get_number_ceil (style->size->min_width);
sizerequest: Stop clamping for_size to natural size Widgets should be given the actual size they will be allocated, so they can do something with it. If they want to clamp themselves to their natural size, nothing's stopping them, they know their natural size after all.
2020-02-22 04:23:41 +00:00
widget_margins_for_size = widget->priv->margin.left + widget->priv->margin.right;
sizerequest: Fix min size with widget margins
2017-05-18 10:16:35 +00:00
}
Fixed GtkExtendedLayout interaction with sizegroups plus cleanups Fixed GtkExtendedLayout to interact with sizegroups, "size-requsts" and caching the values all in the same code segment. Migrated the cache code to be internal to gtkextendedlayout.c
2010-04-17 05:51:10 +00:00
Hook GtkLayoutManager into GtkWidget We delegate the size request mode, the measuring, and the allocation of a widget through a GtkLayoutManager instance, if one has been attached to the widget; otherwise, we fall back to the widget's own implementation.
2018-12-12 17:20:28 +00:00
GtkLayoutManager *layout_manager = gtk_widget_get_layout_manager (widget);
if (layout_manager != NULL)
Formatting and typo fixes
2010-04-24 01:52:55 +00:00
{
Hook GtkLayoutManager into GtkWidget We delegate the size request mode, the measuring, and the allocation of a widget through a GtkLayoutManager instance, if one has been attached to the widget; otherwise, we fall back to the widget's own implementation.
2018-12-12 17:20:28 +00:00
if (for_size < 0)
{
push_recursion_check (widget, orientation);
gtk_layout_manager_measure (layout_manager, widget,
orientation, -1,
&reported_min_size, &reported_nat_size,
&min_baseline, &nat_baseline);
pop_recursion_check (widget, orientation);
}
else
{
int adjusted_for_size;
int minimum_for_size = 0;
int natural_for_size = 0;
/* Pull the minimum for_size from the cache as it's needed to adjust
* the proposed 'for_size' */
gtk_layout_manager_measure (layout_manager, widget,
OPPOSITE_ORIENTATION (orientation), -1,
&minimum_for_size, &natural_for_size,
NULL, NULL);
if (for_size < MAX (minimum_for_size, css_min_for_size))
for_size = MAX (minimum_for_size, css_min_for_size);
sizerequest: Stop clamping for_size to natural size Widgets should be given the actual size they will be allocated, so they can do something with it. If they want to clamp themselves to their natural size, nothing's stopping them, they know their natural size after all.
2020-02-22 04:23:41 +00:00
adjusted_for_size = for_size - widget_margins_for_size;
Hook GtkLayoutManager into GtkWidget We delegate the size request mode, the measuring, and the allocation of a widget through a GtkLayoutManager instance, if one has been attached to the widget; otherwise, we fall back to the widget's own implementation.
2018-12-12 17:20:28 +00:00
adjusted_for_size -= css_extra_for_size;
if (adjusted_for_size < 0)
adjusted_for_size = MAX (minimum_for_size, css_min_for_size);
push_recursion_check (widget, orientation);
gtk_layout_manager_measure (layout_manager, widget,
orientation,
adjusted_for_size,
&reported_min_size, &reported_nat_size,
&min_baseline, &nat_baseline);
pop_recursion_check (widget, orientation);
}
Formatting and typo fixes
2010-04-24 01:52:55 +00:00
}
Fixed GtkExtendedLayout interaction with sizegroups plus cleanups Fixed GtkExtendedLayout to interact with sizegroups, "size-requsts" and caching the values all in the same code segment. Migrated the cache code to be internal to gtkextendedlayout.c
2010-04-17 05:51:10 +00:00
else
Formatting and typo fixes
2010-04-24 01:52:55 +00:00
{
Hook GtkLayoutManager into GtkWidget We delegate the size request mode, the measuring, and the allocation of a widget through a GtkLayoutManager instance, if one has been attached to the widget; otherwise, we fall back to the widget's own implementation.
2018-12-12 17:20:28 +00:00
if (for_size < 0)
{
push_recursion_check (widget, orientation);
widget_class->measure (widget, orientation, -1,
&reported_min_size, &reported_nat_size,
&min_baseline, &nat_baseline);
pop_recursion_check (widget, orientation);
}
else
{
int adjusted_for_size;
int minimum_for_size = 0;
int natural_for_size = 0;
/* Pull the minimum for_size from the cache as it's needed to adjust
* the proposed 'for_size' */
gtk_widget_measure (widget, OPPOSITE_ORIENTATION (orientation), -1,
&minimum_for_size, &natural_for_size, NULL, NULL);
/* TODO: Warn if the given for_size is too small? */
if (for_size < MAX (minimum_for_size, css_min_for_size))
for_size = MAX (minimum_for_size, css_min_for_size);
sizerequest: Stop clamping for_size to natural size Widgets should be given the actual size they will be allocated, so they can do something with it. If they want to clamp themselves to their natural size, nothing's stopping them, they know their natural size after all.
2020-02-22 04:23:41 +00:00
adjusted_for_size = for_size - widget_margins_for_size;
Hook GtkLayoutManager into GtkWidget We delegate the size request mode, the measuring, and the allocation of a widget through a GtkLayoutManager instance, if one has been attached to the widget; otherwise, we fall back to the widget's own implementation.
2018-12-12 17:20:28 +00:00
adjusted_for_size -= css_extra_for_size;
push_recursion_check (widget, orientation);
widget_class->measure (widget,
orientation,
adjusted_for_size,
&reported_min_size, &reported_nat_size,
&min_baseline, &nat_baseline);
pop_recursion_check (widget, orientation);
}
Formatting and typo fixes
2010-04-24 01:52:55 +00:00
}
Fixed GtkExtendedLayout interaction with sizegroups plus cleanups Fixed GtkExtendedLayout to interact with sizegroups, "size-requsts" and caching the values all in the same code segment. Migrated the cache code to be internal to gtkextendedlayout.c
2010-04-17 05:51:10 +00:00
Fix baselines wrt css values The reported minimum baseline is for the reported min height, but if the css min-height is greater than that, we need to account for that fact when saving the baseline. Since the reported baseline is relative to the widget's origin, we also need to add the top values for margin, border and padding to the reported baseline.
2017-06-27 11:27:58 +00:00
min_size = MAX (0, MAX (reported_min_size, css_min_size)) + css_extra_size;
nat_size = MAX (0, MAX (reported_nat_size, css_min_size)) + css_extra_size;
sizerequest: Fix min size with widget margins
2017-05-18 10:16:35 +00:00
sizerequest: Fix min_size > nat_size error message Instead of mentioning the old _get_preferred_xxx functions, mention measure() and print the for_size value as well. The orientation is given by printing either "width" for GTK_ORIENTATION_HORIZONTAL or "height" for GTK_ORIENTATION_VERTICAL.
2017-03-05 13:59:19 +00:00
if (G_UNLIKELY (min_size > nat_size))
Warn if a widget requests minimum size > natural size Since this makes no sense and there's no reason we should have to check for it elsewhere just in case some widget is busted. https://bugzilla.gnome.org/show_bug.cgi?id=628808
2010-09-06 01:46:22 +00:00
{
sizerequest: Fix min_size > nat_size error message Instead of mentioning the old _get_preferred_xxx functions, mention measure() and print the for_size value as well. The orientation is given by printing either "width" for GTK_ORIENTATION_HORIZONTAL or "height" for GTK_ORIENTATION_VERTICAL.
2017-03-05 13:59:19 +00:00
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
Make size request warnings more useful Print the css name of the widget in question, so we have a chance of knowing that this is caused by the marks, not by the slider.
2018-01-09 22:48:51 +00:00
g_warning ("%s %p (%s) reported min width %d and natural width %d in measure() with for_size=%d; natural size must be >= min size",
G_OBJECT_TYPE_NAME (widget), widget,
cssnode: Convert name + id from interned string to GQuark The reason for this is simply that I want to get hash functions that have their values close together, so they can fit in a smaller range (the goal here is 12 bits). By using GQuark, we get consecutive numbers starting with 1 (and applications have <1000 quarks usually), whereas interned strings can be all over the place. As a side effect we also save 64 bytes per declaration.
2020-01-23 23:43:26 +00:00
g_quark_to_string (gtk_css_node_get_name (gtk_widget_get_css_node (widget))),
Make size request warnings more useful Print the css name of the widget in question, so we have a chance of knowing that this is caused by the marks, not by the slider.
2018-01-09 22:48:51 +00:00
min_size, nat_size, for_size);
sizerequest: Fix min_size > nat_size error message Instead of mentioning the old _get_preferred_xxx functions, mention measure() and print the for_size value as well. The orientation is given by printing either "width" for GTK_ORIENTATION_HORIZONTAL or "height" for GTK_ORIENTATION_VERTICAL.
2017-03-05 13:59:19 +00:00
}
else
{
Make size request warnings more useful Print the css name of the widget in question, so we have a chance of knowing that this is caused by the marks, not by the slider.
2018-01-09 22:48:51 +00:00
g_warning ("%s %p (%s) reported min height %d and natural height %d in measure() with for_size=%d; natural size must be >= min size",
G_OBJECT_TYPE_NAME (widget), widget,
cssnode: Convert name + id from interned string to GQuark The reason for this is simply that I want to get hash functions that have their values close together, so they can fit in a smaller range (the goal here is 12 bits). By using GQuark, we get consecutive numbers starting with 1 (and applications have <1000 quarks usually), whereas interned strings can be all over the place. As a side effect we also save 64 bytes per declaration.
2020-01-23 23:43:26 +00:00
g_quark_to_string (gtk_css_node_get_name (gtk_widget_get_css_node (widget))),
Make size request warnings more useful Print the css name of the widget in question, so we have a chance of knowing that this is caused by the marks, not by the slider.
2018-01-09 22:48:51 +00:00
min_size, nat_size, for_size);
sizerequest: Fix min_size > nat_size error message Instead of mentioning the old _get_preferred_xxx functions, mention measure() and print the for_size value as well. The orientation is given by printing either "width" for GTK_ORIENTATION_HORIZONTAL or "height" for GTK_ORIENTATION_VERTICAL.
2017-03-05 13:59:19 +00:00
}
sizerequest: Assert that min_size >= 0 This should generally be true, so remove the checks from gtkbox.c and move it into gtksizerequest.c
2017-06-04 18:13:26 +00:00
nat_size = min_size;
}
else if (G_UNLIKELY (min_size < 0))
{
Make size request warnings more useful Print the css name of the widget in question, so we have a chance of knowing that this is caused by the marks, not by the slider.
2018-01-09 22:48:51 +00:00
g_warning ("%s %p (%s) reported min %s %d, but sizes must be >= 0",
sizerequest: Assert that min_size >= 0 This should generally be true, so remove the checks from gtkbox.c and move it into gtksizerequest.c
2017-06-04 18:13:26 +00:00
G_OBJECT_TYPE_NAME (widget), widget,
cssnode: Convert name + id from interned string to GQuark The reason for this is simply that I want to get hash functions that have their values close together, so they can fit in a smaller range (the goal here is 12 bits). By using GQuark, we get consecutive numbers starting with 1 (and applications have <1000 quarks usually), whereas interned strings can be all over the place. As a side effect we also save 64 bytes per declaration.
2020-01-23 23:43:26 +00:00
g_quark_to_string (gtk_css_node_get_name (gtk_widget_get_css_node (widget))),
sizerequest: Assert that min_size >= 0 This should generally be true, so remove the checks from gtkbox.c and move it into gtksizerequest.c
2017-06-04 18:13:26 +00:00
orientation == GTK_ORIENTATION_HORIZONTAL ? "width" : "height",
min_size);
min_size = 0;
nat_size = MAX (0, min_size);
Warn if a widget requests minimum size > natural size Since this makes no sense and there's no reason we should have to check for it elsewhere just in case some widget is busted. https://bugzilla.gnome.org/show_bug.cgi?id=628808
2010-09-06 01:46:22 +00:00
}
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
adjusted_min = min_size;
adjusted_natural = nat_size;
widget: Remove unused adjust_* vfuncs Expose them privately to gtksizerequest.c using normal functions instead.
2016-11-23 16:46:44 +00:00
gtk_widget_adjust_size_request (widget, orientation,
&adjusted_min, &adjusted_natural);
GtkWidget: add adjust_size_request adjust_size_allocation virtual funcs Use these new methods to handle set_size_request (aka aux_info) inside gtkwidget.c, instead of having external code mess with it. The virtual functions can be used for other purposes in the future. For example, GtkContainer::border_width could be automatically implemented for all container subclasses.
2010-09-05 16:19:14 +00:00
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
if (adjusted_min < min_size ||
adjusted_natural < nat_size)
GtkWidget: add adjust_size_request adjust_size_allocation virtual funcs Use these new methods to handle set_size_request (aka aux_info) inside gtkwidget.c, instead of having external code mess with it. The virtual functions can be used for other purposes in the future. For example, GtkContainer::border_width could be automatically implemented for all container subclasses.
2010-09-05 16:19:14 +00:00
{
g_warning ("%s %p adjusted size %s min %d natural %d must not decrease below min %d natural %d",
Stop calling GtkWidget parameters 'request' There were at least a few places where we were using GTK_WIDGET() on something that was already a GtkWidget*, just because it was named wrong.
2010-10-26 14:53:46 +00:00
G_OBJECT_TYPE_NAME (widget), widget,
sizerequest: Use GtkOrientation ... instead of GtkSizeGroupMode. Orientation is what we're interested in after all. When we need a GtkSizeGroupMode, we can do the translation where we need it.
2012-11-14 00:25:21 +00:00
orientation == GTK_ORIENTATION_VERTICAL ? "vertical" : "horizontal",
GtkWidget: add adjust_size_request adjust_size_allocation virtual funcs Use these new methods to handle set_size_request (aka aux_info) inside gtkwidget.c, instead of having external code mess with it. The virtual functions can be used for other purposes in the future. For example, GtkContainer::border_width could be automatically implemented for all container subclasses.
2010-09-05 16:19:14 +00:00
adjusted_min, adjusted_natural,
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
min_size, nat_size);
GtkWidget: add adjust_size_request adjust_size_allocation virtual funcs Use these new methods to handle set_size_request (aka aux_info) inside gtkwidget.c, instead of having external code mess with it. The virtual functions can be used for other purposes in the future. For example, GtkContainer::border_width could be automatically implemented for all container subclasses.
2010-09-05 16:19:14 +00:00
/* don't use the adjustment */
}
else if (adjusted_min > adjusted_natural)
{
g_warning ("%s %p adjusted size %s min %d natural %d original min %d natural %d has min greater than natural",
Stop calling GtkWidget parameters 'request' There were at least a few places where we were using GTK_WIDGET() on something that was already a GtkWidget*, just because it was named wrong.
2010-10-26 14:53:46 +00:00
G_OBJECT_TYPE_NAME (widget), widget,
sizerequest: Use GtkOrientation ... instead of GtkSizeGroupMode. Orientation is what we're interested in after all. When we need a GtkSizeGroupMode, we can do the translation where we need it.
2012-11-14 00:25:21 +00:00
orientation == GTK_ORIENTATION_VERTICAL ? "vertical" : "horizontal",
GtkWidget: add adjust_size_request adjust_size_allocation virtual funcs Use these new methods to handle set_size_request (aka aux_info) inside gtkwidget.c, instead of having external code mess with it. The virtual functions can be used for other purposes in the future. For example, GtkContainer::border_width could be automatically implemented for all container subclasses.
2010-09-05 16:19:14 +00:00
adjusted_min, adjusted_natural,
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
min_size, nat_size);
GtkWidget: add adjust_size_request adjust_size_allocation virtual funcs Use these new methods to handle set_size_request (aka aux_info) inside gtkwidget.c, instead of having external code mess with it. The virtual functions can be used for other purposes in the future. For example, GtkContainer::border_width could be automatically implemented for all container subclasses.
2010-09-05 16:19:14 +00:00
/* don't use the adjustment */
}
else
{
/* adjustment looks good */
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
min_size = adjusted_min;
nat_size = adjusted_natural;
GtkWidget: add adjust_size_request adjust_size_allocation virtual funcs Use these new methods to handle set_size_request (aka aux_info) inside gtkwidget.c, instead of having external code mess with it. The virtual functions can be used for other purposes in the future. For example, GtkContainer::border_width could be automatically implemented for all container subclasses.
2010-09-05 16:19:14 +00:00
}
sizerequest: Only check reported baselines if requested If the passed-in store locations for the baselines are NULL anyway, we don't need to check the reported baselines for correctness.
2018-07-15 15:56:11 +00:00
if (baselines_requested && (min_baseline != -1 || nat_baseline != -1))
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
g_warning ("%s %p reported a horizontal baseline",
G_OBJECT_TYPE_NAME (widget), widget);
min_baseline = -1;
nat_baseline = -1;
}
else if (min_baseline == -1 || nat_baseline == -1)
{
g_warning ("%s %p reported baseline for only one of min/natural (min: %d, natural: %d)",
G_OBJECT_TYPE_NAME (widget), widget,
min_baseline, nat_baseline);
min_baseline = -1;
nat_baseline = -1;
}
sizerequest: Add more assertions for baselines min baselines must be <= natural baselines and both must lie inside the content size of the widget.
2017-07-04 09:35:06 +00:00
else if (min_baseline > reported_min_size ||
nat_baseline > reported_nat_size ||
min_baseline < 0 ||
nat_baseline < 0)
{
g_warning ("%s %p reported baselines of minimum %d and natural %d, but sizes of "
"minimum %d and natural %d. Baselines must be inside the widget size.",
G_OBJECT_TYPE_NAME (widget), widget, min_baseline, nat_baseline,
reported_min_size, reported_nat_size);
min_baseline = -1;
nat_baseline = -1;
}
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
else
Fix baselines wrt css values The reported minimum baseline is for the reported min height, but if the css min-height is greater than that, we need to account for that fact when saving the baseline. Since the reported baseline is relative to the widget's origin, we also need to add the top values for margin, border and padding to the reported baseline.
2017-06-27 11:27:58 +00:00
{
if (css_min_size > reported_min_size)
{
min_baseline += (css_min_size - reported_min_size) / 2;
nat_baseline += (css_min_size - reported_min_size) / 2;
}
min_baseline += margin.top + border.top + padding.top;
nat_baseline += margin.top + border.top + padding.top;
gtk_widget_adjust_baseline_request (widget, &min_baseline, &nat_baseline);
}
}
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
sizerequestcache: Move lookup function ...and clean up its API.
2012-11-14 00:10:21 +00:00
_gtk_size_request_cache_commit (cache,
sizerequestcache: Move commit function
2012-11-13 23:55:50 +00:00
orientation,
for_size,
min_size,
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
nat_size,
min_baseline,
nat_baseline);
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
}
Fixed GtkExtendedLayout interaction with sizegroups plus cleanups Fixed GtkExtendedLayout to interact with sizegroups, "size-requsts" and caching the values all in the same code segment. Migrated the cache code to be internal to gtkextendedlayout.c
2010-04-17 05:51:10 +00:00
sizerequest: Stop checking orientation in query_size_for_orientation Since we have ->measure now, we can implement this code more elegantly.
2017-05-18 08:11:54 +00:00
if (minimum)
*minimum = min_size;
Some doc and formatting tweaks
2010-04-28 14:04:21 +00:00
sizerequest: Stop checking orientation in query_size_for_orientation Since we have ->measure now, we can implement this code more elegantly.
2017-05-18 08:11:54 +00:00
if (natural)
*natural = nat_size;
Fixed GtkExtendedLayout interaction with sizegroups plus cleanups Fixed GtkExtendedLayout to interact with sizegroups, "size-requsts" and caching the values all in the same code segment. Migrated the cache code to be internal to gtkextendedlayout.c
2010-04-17 05:51:10 +00:00
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
if (minimum_baseline)
*minimum_baseline = min_baseline;
if (natural_baseline)
*natural_baseline = nat_baseline;
Cache heights-for-range-of-widths instead of height for every width. This patch optimizes window resizes by assuming that if a widget has the same height at a width of 50 as with a width of 150, the height for width 100 will also be the same. The patch also further optimizes the cache allocator, now there are 2 pointer arrays of up to a maximum of 5 requests, the arrays will only be allocated if a request is ever made in that orientation and the array will be sparse until each request is made (i.e. if a label can only wrap to 3 lines, there will only be 3 out of a possible 5 SizeRequest structures allocated to cache it).
2011-03-06 06:13:56 +00:00
g_assert (min_size <= nat_size);
Fixed GtkExtendedLayout interaction with sizegroups plus cleanups Fixed GtkExtendedLayout to interact with sizegroups, "size-requsts" and caching the values all in the same code segment. Migrated the cache code to be internal to gtkextendedlayout.c
2010-04-17 05:51:10 +00:00
Use inlined gtk_widget_get_display version in a few places We can safely do this whenever we already made sure that the given pointer is a valid GtkWidget.
2018-04-21 15:04:41 +00:00
GTK_DISPLAY_NOTE (_gtk_widget_get_display (widget), SIZE_REQUEST, {
Don't use g_print for debug output The g_print documentation explicitly says not to do this, since g_print is meant to be redirected by applications. Instead use g_message for logging that can be triggered via GTK_DEBUG.
2016-02-28 20:33:18 +00:00
GString *s;
s = g_string_new ("");
g_string_append_printf (s, "[%p] %s\t%s: %d is minimum %d and natural: %d",
widget, G_OBJECT_TYPE_NAME (widget),
orientation == GTK_ORIENTATION_HORIZONTAL
? "width for height"
: "height for width",
for_size, min_size, nat_size);
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
if (min_baseline != -1 || nat_baseline != -1)
Add braces to appease gcc -ftrack-macro-expansion=0 doesn't like if statements without braces when evaluating indentation levels.
2016-08-25 21:01:28 +00:00
{
g_string_append_printf (s, ", baseline %d/%d",
min_baseline, nat_baseline);
}
Don't use g_print for debug output The g_print documentation explicitly says not to do this, since g_print is meant to be redirected by applications. Instead use g_message for logging that can be triggered via GTK_DEBUG.
2016-02-28 20:33:18 +00:00
g_string_append_printf (s, " (hit cache: %s)\n",
found_in_cache ? "yes" : "no");
g_message ("%s", s->str);
g_string_free (s, TRUE);
});
sizerequest: Restructure code Make the compute_size_request() function take into account size groups itself instead of doing a weird "bump_requisition" call.
2012-11-04 15:10:20 +00:00
}
sizerequest: rename _compute_size_for_orientation to _measure They have the exact same parameters and gtk_widget_measure did unnecessary work before. Also better stack traces!
2016-11-12 21:15:48 +00:00
/**
* gtk_widget_measure:
* @widget: A #GtkWidget instance
* @orientation: the orientation to measure
* @for_size: Size for the opposite of @orientation, i.e.
* if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is
* the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL
* case is analogous. This way, both height-for-width and width-for-height
* requests can be implemented. If no size is known, -1 can be passed.
* @minimum: (out) (optional): location to store the minimum size, or %NULL
* @natural: (out) (optional): location to store the natural size, or %NULL
* @minimum_baseline: (out) (optional): location to store the baseline
* position for the minimum size, or %NULL
* @natural_baseline: (out) (optional): location to store the baseline
* position for the natural size, or %NULL
*
* Measures @widget in the orientation @orientation and for the given @for_size.
Correctly mark an enum value in a doc comment
2018-07-15 16:02:47 +00:00
* As an example, if @orientation is %GTK_ORIENTATION_HORIZONTAL and @for_size is 300,
sizerequest: rename _compute_size_for_orientation to _measure They have the exact same parameters and gtk_widget_measure did unnecessary work before. Also better stack traces!
2016-11-12 21:15:48 +00:00
* this functions will compute the minimum and natural width of @widget if
* it is allocated at a height of 300 pixels.
*
Move geometry management docs do GtkWidget Both GtkWidget and GtkContainer had similar docs regarding hfw/wfh geometry management. Move these just to GtkWidget. Also make sure the examples compile, port everything from gtk_preferred_* to measure and replace some occurrences of "container" with "widget" where container was just used to refer to a widget with child widgets.
2018-01-03 15:14:47 +00:00
* See [GtkWidget’s geometry management section][geometry-management] for
* a more details on implementing #GtkWidgetClass.measure().
sizerequest: Restructure code Make the compute_size_request() function take into account size groups itself instead of doing a weird "bump_requisition" call.
2012-11-04 15:10:20 +00:00
*/
sizerequest: rename _compute_size_for_orientation to _measure They have the exact same parameters and gtk_widget_measure did unnecessary work before. Also better stack traces!
2016-11-12 21:15:48 +00:00
void
gtk_widget_measure (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
sizerequest: Restructure code Make the compute_size_request() function take into account size groups itself instead of doing a weird "bump_requisition" call.
2012-11-04 15:10:20 +00:00
{
sizerequest: rename _compute_size_for_orientation to _measure They have the exact same parameters and gtk_widget_measure did unnecessary work before. Also better stack traces!
2016-11-12 21:15:48 +00:00
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (for_size >= -1);
g_return_if_fail (orientation == GTK_ORIENTATION_HORIZONTAL ||
orientation == GTK_ORIENTATION_VERTICAL);
/* This is the main function that checks for a cached size and
* possibly queries the widget class to compute the size if it's
* not cached.
*/
Stop using gtk_widget_is_toplevel
2019-05-20 03:31:03 +00:00
if (!_gtk_widget_get_visible (widget) && !GTK_IS_ROOT (widget))
sizerequest: Make invisible widgets return a 0x0 size.
2013-01-08 11:26:04 +00:00
{
if (minimum)
*minimum = 0;
if (natural)
*natural = 0;
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
if (minimum_baseline)
*minimum_baseline = -1;
if (natural_baseline)
*natural_baseline = -1;
sizerequest: Make invisible widgets return a 0x0 size.
2013-01-08 11:26:04 +00:00
return;
}
sizerequest: Restructure code Make the compute_size_request() function take into account size groups itself instead of doing a weird "bump_requisition" call.
2012-11-04 15:10:20 +00:00
if (G_LIKELY (!_gtk_widget_get_sizegroups (widget)))
{
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
gtk_widget_query_size_for_orientation (widget, orientation, for_size, minimum, natural,
sizerequest: Move css handling to gtk_widget_measure We need to adjust the passed for_size to fit into the content allocation of the widget. That also means that we can't call gtk_widget_measure(widget) inside gtk_widget_measure(widget) since now the for_size will be adjusted twice.
2017-05-06 08:02:03 +00:00
minimum_baseline, natural_baseline);
sizerequest: Restructure code Make the compute_size_request() function take into account size groups itself instead of doing a weird "bump_requisition" call.
2012-11-04 15:10:20 +00:00
}
sizerequest: Pull locals into closest scope
2018-07-15 16:08:30 +00:00
else
{
GHashTable *widgets;
GHashTableIter iter;
gpointer key;
int min_result = 0, nat_result = 0;
Fixed GtkExtendedLayout interaction with sizegroups plus cleanups Fixed GtkExtendedLayout to interact with sizegroups, "size-requsts" and caching the values all in the same code segment. Migrated the cache code to be internal to gtkextendedlayout.c
2010-04-17 05:51:10 +00:00
sizerequest: Pull locals into closest scope
2018-07-15 16:08:30 +00:00
widgets = _gtk_size_group_get_widget_peers (widget, orientation);
sizerequest: Restructure code Make the compute_size_request() function take into account size groups itself instead of doing a weird "bump_requisition" call.
2012-11-04 15:10:20 +00:00
sizerequest: Pull locals into closest scope
2018-07-15 16:08:30 +00:00
g_hash_table_iter_init (&iter, widgets);
while (g_hash_table_iter_next (&iter, &key, NULL))
{
GtkWidget *tmp_widget = key;
int min_dimension, nat_dimension;
sizerequest: Restructure code Make the compute_size_request() function take into account size groups itself instead of doing a weird "bump_requisition" call.
2012-11-04 15:10:20 +00:00
sizerequest: Pull locals into closest scope
2018-07-15 16:08:30 +00:00
gtk_widget_query_size_for_orientation (tmp_widget, orientation, for_size,
&min_dimension, &nat_dimension, NULL, NULL);
sizerequest: Restructure code Make the compute_size_request() function take into account size groups itself instead of doing a weird "bump_requisition" call.
2012-11-04 15:10:20 +00:00
sizerequest: Pull locals into closest scope
2018-07-15 16:08:30 +00:00
min_result = MAX (min_result, min_dimension);
nat_result = MAX (nat_result, nat_dimension);
}
sizerequest: Restructure code Make the compute_size_request() function take into account size groups itself instead of doing a weird "bump_requisition" call.
2012-11-04 15:10:20 +00:00
sizerequest: Pull locals into closest scope
2018-07-15 16:08:30 +00:00
g_hash_table_destroy (widgets);
sizerequest: Restructure code Make the compute_size_request() function take into account size groups itself instead of doing a weird "bump_requisition" call.
2012-11-04 15:10:20 +00:00
sizerequest: Pull locals into closest scope
2018-07-15 16:08:30 +00:00
/* Baselines make no sense with sizegroups really */
if (minimum_baseline)
*minimum_baseline = -1;
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
sizerequest: Pull locals into closest scope
2018-07-15 16:08:30 +00:00
if (natural_baseline)
*natural_baseline = -1;
Initial support for baselines This modifies the size machinery in order to allow baseline support. We add a new widget vfunc get_preferred_height_and_baseline_for_width which queries the normal height_for_width (or non-for-width if width is -1) and additionally returns optional (-1 means "no baseline") baselines for the minimal and natural heights. We also add a new gtk_widget_size_allocate_with_baseline() which baseline-aware containers can use to allocate children with a specific baseline, either one inherited from the parent, or one introduced due to requested baseline alignment in the container itself. size_allocate_with_baseline() works just like a normal size allocation, except the baseline gets recorded so that the child can access it via gtk_widget_get_allocated_baseline() when it aligns itself. There are also adjust_baseline_request/allocation similar to the allocation adjustment, and we extend the size request cache to also store the baselines.
2013-03-05 13:54:03 +00:00
sizerequest: Pull locals into closest scope
2018-07-15 16:08:30 +00:00
if (minimum)
*minimum = min_result;
sizerequest: do not derefence NULL pointers
2012-11-04 16:42:55 +00:00
sizerequest: Pull locals into closest scope
2018-07-15 16:08:30 +00:00
if (natural)
*natural = nat_result;
}
Fixed GtkExtendedLayout interaction with sizegroups plus cleanups Fixed GtkExtendedLayout to interact with sizegroups, "size-requsts" and caching the values all in the same code segment. Migrated the cache code to be internal to gtkextendedlayout.c
2010-04-17 05:51:10 +00:00
}
Added gtk_extended_layout_is_height_for_width() Added an indicator telling whether a widget prefers to be allocated as height-for-width or width-for-height. Usually this depends on the orientation of a container or the nature of a content widget like GtkLabel. This indicator is only used in the seldom case where a parent is allocating free space to the child and the child can flow in either direction, GtkWindow and GtkScrolledWindow are users of this api.
2010-04-11 02:32:55 +00:00
/**
Fixing documentation of gtk_widget_get_request_mode()
2010-09-27 06:11:27 +00:00
* gtk_widget_get_request_mode:
Move GtkSizeRequest into GtkWidget It doesn't make sense to keep them separate as GtkSizeRequest requires a GtkWidget and GtkWidget implements GtkSizeRequest, so you can never have one without the other. It also makes the code a lot easier because no casts are required when calling functions. Also, the names would translate to gtk_widget_get_width() and people agreed that this would be a too generic name, so a "preferred" was added to the names. So this patch moves the functions: gtk_size_request_get_request_mode() => gtk_widget_get_request_mode() gtk_size_request_get_width() => gtk_widget_get_preferred_width() gtk_size_request_get_height() => gtk_widget_get_preferred_height() gtk_size_request_get_size() => gtk_widget_get_preferred_size() gtk_size_request_get_width_for_height() => gtk_widget_get_preferred_width_for_height() gtk_size_request_get_height_for_width() => gtk_widget_get_preferred_height_for_width() ... and moves the corresponding vfuncs to the GtkWidgetClass. The patch also renames the implementations of the vfuncs in widgets to include the word "preferrred".
2010-09-21 14:35:17 +00:00
* @widget: a #GtkWidget instance
Added gtk_extended_layout_is_height_for_width() Added an indicator telling whether a widget prefers to be allocated as height-for-width or width-for-height. Usually this depends on the orientation of a container or the nature of a content widget like GtkLabel. This indicator is only used in the seldom case where a parent is allocating free space to the child and the child can flow in either direction, GtkWindow and GtkScrolledWindow are users of this api.
2010-04-11 02:32:55 +00:00
*
* Gets whether the widget prefers a height-for-width layout
Formatting and typo fixes
2010-04-24 01:52:55 +00:00
* or a width-for-height layout.
*
Docs: Don't use note elements In most cases, the text itself makes the message clear enough.
2014-02-02 06:22:14 +00:00
* #GtkBin widgets generally propagate the preference of
Formatting and typo fixes
2010-04-24 01:52:55 +00:00
* their child, container widgets need to request something either in
* context of their children or in context of their allocation
Docs: Don't use note elements In most cases, the text itself makes the message clear enough.
2014-02-02 06:22:14 +00:00
* capabilities.
Added gtk_extended_layout_is_height_for_width() Added an indicator telling whether a widget prefers to be allocated as height-for-width or width-for-height. Usually this depends on the orientation of a container or the nature of a content widget like GtkLabel. This indicator is only used in the seldom case where a parent is allocating free space to the child and the child can flow in either direction, GtkWindow and GtkScrolledWindow are users of this api.
2010-04-11 02:32:55 +00:00
*
Added gtk_distribute_allocation() Added a convenience api for containers to use when allocating children (used to distribute space evenly to children).
2010-08-05 16:45:48 +00:00
* Returns: The #GtkSizeRequestMode preferred by @widget.
Added gtk_extended_layout_is_height_for_width() Added an indicator telling whether a widget prefers to be allocated as height-for-width or width-for-height. Usually this depends on the orientation of a container or the nature of a content widget like GtkLabel. This indicator is only used in the seldom case where a parent is allocating free space to the child and the child can flow in either direction, GtkWindow and GtkScrolledWindow are users of this api.
2010-04-11 02:32:55 +00:00
*/
Mass api change from GtkExtendedLayout --> GtkSizeRequest This commit makes a few massive changes to the extended layout code: a.) gtkextendedlayout.c --> gtksizerequest.c b.) _is_height_for_width --> get_request_mode() c.) get_desired_size(), get_desired_width(), get_desired_height() --> get_size(), get_width(), get_height() This is the first partial commit and only effects portions of the tree that have already been merged in master (in order to easily cherry pick this commit). Conflicts: gtk/Makefile.am gtk/gtk.h gtk/gtk.symbols gtk/gtkextendedlayout.h
2010-06-18 04:11:26 +00:00
GtkSizeRequestMode
Move GtkSizeRequest into GtkWidget It doesn't make sense to keep them separate as GtkSizeRequest requires a GtkWidget and GtkWidget implements GtkSizeRequest, so you can never have one without the other. It also makes the code a lot easier because no casts are required when calling functions. Also, the names would translate to gtk_widget_get_width() and people agreed that this would be a too generic name, so a "preferred" was added to the names. So this patch moves the functions: gtk_size_request_get_request_mode() => gtk_widget_get_request_mode() gtk_size_request_get_width() => gtk_widget_get_preferred_width() gtk_size_request_get_height() => gtk_widget_get_preferred_height() gtk_size_request_get_size() => gtk_widget_get_preferred_size() gtk_size_request_get_width_for_height() => gtk_widget_get_preferred_width_for_height() gtk_size_request_get_height_for_width() => gtk_widget_get_preferred_height_for_width() ... and moves the corresponding vfuncs to the GtkWidgetClass. The patch also renames the implementations of the vfuncs in widgets to include the word "preferrred".
2010-09-21 14:35:17 +00:00
gtk_widget_get_request_mode (GtkWidget *widget)
Added gtk_extended_layout_is_height_for_width() Added an indicator telling whether a widget prefers to be allocated as height-for-width or width-for-height. Usually this depends on the orientation of a container or the nature of a content widget like GtkLabel. This indicator is only used in the seldom case where a parent is allocating free space to the child and the child can flow in either direction, GtkWindow and GtkScrolledWindow are users of this api.
2010-04-11 02:32:55 +00:00
{
sizerequest: Cache the request mode ... in the GtkSizeRequestCache. That way, we only need to query it once, and can remove the caching code from GtkContainer.
2012-11-13 21:02:53 +00:00
SizeRequestCache *cache;
cache = _gtk_widget_peek_request_cache (widget);
Remove type check from gtk_widget_get_request_mode
2015-09-11 13:08:36 +00:00
if (G_UNLIKELY (!cache->request_mode_valid))
sizerequest: Cache the request mode ... in the GtkSizeRequestCache. That way, we only need to query it once, and can remove the caching code from GtkContainer.
2012-11-13 21:02:53 +00:00
{
sizerequest: Fix request mode for layout managers We can't just call GtkWidgetClass::get_request_mode() anymore. If the widget has a layout manager, we need to ask that one.
2019-05-25 07:03:37 +00:00
cache->request_mode = fetch_request_mode (widget);
sizerequest: Cache the request mode ... in the GtkSizeRequestCache. That way, we only need to query it once, and can remove the caching code from GtkContainer.
2012-11-13 21:02:53 +00:00
cache->request_mode_valid = TRUE;
}
return cache->request_mode;
Added gtk_extended_layout_is_height_for_width() Added an indicator telling whether a widget prefers to be allocated as height-for-width or width-for-height. Usually this depends on the orientation of a container or the nature of a content widget like GtkLabel. This indicator is only used in the seldom case where a parent is allocating free space to the child and the child can flow in either direction, GtkWindow and GtkScrolledWindow are users of this api.
2010-04-11 02:32:55 +00:00
}
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
/**
* gtk_widget_get_preferred_size:
Move GtkSizeRequest into GtkWidget It doesn't make sense to keep them separate as GtkSizeRequest requires a GtkWidget and GtkWidget implements GtkSizeRequest, so you can never have one without the other. It also makes the code a lot easier because no casts are required when calling functions. Also, the names would translate to gtk_widget_get_width() and people agreed that this would be a too generic name, so a "preferred" was added to the names. So this patch moves the functions: gtk_size_request_get_request_mode() => gtk_widget_get_request_mode() gtk_size_request_get_width() => gtk_widget_get_preferred_width() gtk_size_request_get_height() => gtk_widget_get_preferred_height() gtk_size_request_get_size() => gtk_widget_get_preferred_size() gtk_size_request_get_width_for_height() => gtk_widget_get_preferred_width_for_height() gtk_size_request_get_height_for_width() => gtk_widget_get_preferred_height_for_width() ... and moves the corresponding vfuncs to the GtkWidgetClass. The patch also renames the implementations of the vfuncs in widgets to include the word "preferrred".
2010-09-21 14:35:17 +00:00
* @widget: a #GtkWidget instance
[GtkExtendedLayout] Add annotations Add missing annotations for out values.
2010-05-12 22:53:43 +00:00
* @minimum_size: (out) (allow-none): location for storing the minimum size, or %NULL
* @natural_size: (out) (allow-none): location for storing the natural size, or %NULL
Mega commit to change ->get_desired_size() for ->get_desired_width/height(). This commit changes gtk_extended_layout_get_desired_size() for per dimension variants. Furthermore this commit reverts the actions done in size-groups for now as it needs a different approach. The natural width/height parameters added to aux_info have been changed for a per width cache for heights and a per height cache for widths. gtk-demo is still working, currently sizegroups are not taken into account as mentioned above - size groups need to be alerted both when the widths and heights are updated independantly and then that information needs to repropagate also to other extended layout implementors.
2010-04-13 02:21:46 +00:00
*
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
* Retrieves the minimum and natural size of a widget, taking
* into account the widget’s preference for height-for-width management.
Mega commit to change ->get_desired_size() for ->get_desired_width/height(). This commit changes gtk_extended_layout_get_desired_size() for per dimension variants. Furthermore this commit reverts the actions done in size-groups for now as it needs a different approach. The natural width/height parameters added to aux_info have been changed for a per width cache for heights and a per height cache for widths. gtk-demo is still working, currently sizegroups are not taken into account as mentioned above - size groups need to be alerted both when the widths and heights are updated independantly and then that information needs to repropagate also to other extended layout implementors.
2010-04-13 02:21:46 +00:00
*
Formatting and typo fixes
2010-04-24 01:52:55 +00:00
* This is used to retrieve a suitable size by container widgets which do
Migrated old GtkSizeRequestIface documentation to GtkWidget and added notes to gtk_widget_get_preferred_size().
2010-10-08 14:10:42 +00:00
* not impose any restrictions on the child placement. It can be used
* to deduce toplevel window and menu sizes as well as child widgets in
GtkWidget/GtkContainer: Slight fixes to geometry-management docs. Replace it's with its in several places. Replace some , with . Replace some ; with . Fix some plurals. Other minor corrections.
2010-11-04 15:30:48 +00:00
* free-form containers such as GtkLayout.
Migrated old GtkSizeRequestIface documentation to GtkWidget and added notes to gtk_widget_get_preferred_size().
2010-10-08 14:10:42 +00:00
*
Docs: Don't use note elements In most cases, the text itself makes the message clear enough.
2014-02-02 06:22:14 +00:00
* Handle with care. Note that the natural height of a height-for-width
Migrated old GtkSizeRequestIface documentation to GtkWidget and added notes to gtk_widget_get_preferred_size().
2010-10-08 14:10:42 +00:00
* widget will generally be a smaller size than the minimum height, since the required
* height for the natural width is generally smaller than the required height for
Docs: Don't use note elements In most cases, the text itself makes the message clear enough.
2014-02-02 06:22:14 +00:00
* the minimum width.
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
*
* Use gtk_widget_measure() if you want to support
* baseline alignment.
Mega commit to change ->get_desired_size() for ->get_desired_width/height(). This commit changes gtk_extended_layout_get_desired_size() for per dimension variants. Furthermore this commit reverts the actions done in size-groups for now as it needs a different approach. The natural width/height parameters added to aux_info have been changed for a per width cache for heights and a per height cache for widths. gtk-demo is still working, currently sizegroups are not taken into account as mentioned above - size groups need to be alerted both when the widths and heights are updated independantly and then that information needs to repropagate also to other extended layout implementors.
2010-04-13 02:21:46 +00:00
*/
void
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
gtk_widget_get_preferred_size (GtkWidget *widget,
GtkRequisition *minimum_size,
GtkRequisition *natural_size)
Mega commit to change ->get_desired_size() for ->get_desired_width/height(). This commit changes gtk_extended_layout_get_desired_size() for per dimension variants. Furthermore this commit reverts the actions done in size-groups for now as it needs a different approach. The natural width/height parameters added to aux_info have been changed for a per width cache for heights and a per height cache for widths. gtk-demo is still working, currently sizegroups are not taken into account as mentioned above - size groups need to be alerted both when the widths and heights are updated independantly and then that information needs to repropagate also to other extended layout implementors.
2010-04-13 02:21:46 +00:00
{
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
int min_width, nat_width;
int min_height, nat_height;
Mega commit to change ->get_desired_size() for ->get_desired_width/height(). This commit changes gtk_extended_layout_get_desired_size() for per dimension variants. Furthermore this commit reverts the actions done in size-groups for now as it needs a different approach. The natural width/height parameters added to aux_info have been changed for a per width cache for heights and a per height cache for widths. gtk-demo is still working, currently sizegroups are not taken into account as mentioned above - size groups need to be alerted both when the widths and heights are updated independantly and then that information needs to repropagate also to other extended layout implementors.
2010-04-13 02:21:46 +00:00
Move GtkSizeRequest into GtkWidget It doesn't make sense to keep them separate as GtkSizeRequest requires a GtkWidget and GtkWidget implements GtkSizeRequest, so you can never have one without the other. It also makes the code a lot easier because no casts are required when calling functions. Also, the names would translate to gtk_widget_get_width() and people agreed that this would be a too generic name, so a "preferred" was added to the names. So this patch moves the functions: gtk_size_request_get_request_mode() => gtk_widget_get_request_mode() gtk_size_request_get_width() => gtk_widget_get_preferred_width() gtk_size_request_get_height() => gtk_widget_get_preferred_height() gtk_size_request_get_size() => gtk_widget_get_preferred_size() gtk_size_request_get_width_for_height() => gtk_widget_get_preferred_width_for_height() gtk_size_request_get_height_for_width() => gtk_widget_get_preferred_height_for_width() ... and moves the corresponding vfuncs to the GtkWidgetClass. The patch also renames the implementations of the vfuncs in widgets to include the word "preferrred".
2010-09-21 14:35:17 +00:00
g_return_if_fail (GTK_IS_WIDGET (widget));
Mega commit to change ->get_desired_size() for ->get_desired_width/height(). This commit changes gtk_extended_layout_get_desired_size() for per dimension variants. Furthermore this commit reverts the actions done in size-groups for now as it needs a different approach. The natural width/height parameters added to aux_info have been changed for a per width cache for heights and a per height cache for widths. gtk-demo is still working, currently sizegroups are not taken into account as mentioned above - size groups need to be alerted both when the widths and heights are updated independantly and then that information needs to repropagate also to other extended layout implementors.
2010-04-13 02:21:46 +00:00
Move GtkSizeRequest into GtkWidget It doesn't make sense to keep them separate as GtkSizeRequest requires a GtkWidget and GtkWidget implements GtkSizeRequest, so you can never have one without the other. It also makes the code a lot easier because no casts are required when calling functions. Also, the names would translate to gtk_widget_get_width() and people agreed that this would be a too generic name, so a "preferred" was added to the names. So this patch moves the functions: gtk_size_request_get_request_mode() => gtk_widget_get_request_mode() gtk_size_request_get_width() => gtk_widget_get_preferred_width() gtk_size_request_get_height() => gtk_widget_get_preferred_height() gtk_size_request_get_size() => gtk_widget_get_preferred_size() gtk_size_request_get_width_for_height() => gtk_widget_get_preferred_width_for_height() gtk_size_request_get_height_for_width() => gtk_widget_get_preferred_height_for_width() ... and moves the corresponding vfuncs to the GtkWidgetClass. The patch also renames the implementations of the vfuncs in widgets to include the word "preferrred".
2010-09-21 14:35:17 +00:00
if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
Mega commit to change ->get_desired_size() for ->get_desired_width/height(). This commit changes gtk_extended_layout_get_desired_size() for per dimension variants. Furthermore this commit reverts the actions done in size-groups for now as it needs a different approach. The natural width/height parameters added to aux_info have been changed for a per width cache for heights and a per height cache for widths. gtk-demo is still working, currently sizegroups are not taken into account as mentioned above - size groups need to be alerted both when the widths and heights are updated independantly and then that information needs to repropagate also to other extended layout implementors.
2010-04-13 02:21:46 +00:00
{
Remove gtk_widget_get_preferred_* They are unnecessary now that we have gtk_widget_measure.
2017-05-02 19:50:50 +00:00
gtk_widget_measure (widget, GTK_ORIENTATION_HORIZONTAL, -1,
&min_width, &nat_width, NULL, NULL);
Mass api change from GtkExtendedLayout --> GtkSizeRequest This commit makes a few massive changes to the extended layout code: a.) gtkextendedlayout.c --> gtksizerequest.c b.) _is_height_for_width --> get_request_mode() c.) get_desired_size(), get_desired_width(), get_desired_height() --> get_size(), get_width(), get_height() This is the first partial commit and only effects portions of the tree that have already been merged in master (in order to easily cherry pick this commit). Conflicts: gtk/Makefile.am gtk/gtk.h gtk/gtk.symbols gtk/gtkextendedlayout.h
2010-06-18 04:11:26 +00:00
if (minimum_size)
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
{
minimum_size->width = min_width;
Remove gtk_widget_get_preferred_height_and_baseline_for_width It's just a wrapper around gtk_widget_measure nowadays.
2016-11-23 17:05:09 +00:00
gtk_widget_measure (widget,
GTK_ORIENTATION_VERTICAL, min_width,
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
&minimum_size->height, NULL, NULL, NULL);
}
Mass api change from GtkExtendedLayout --> GtkSizeRequest This commit makes a few massive changes to the extended layout code: a.) gtkextendedlayout.c --> gtksizerequest.c b.) _is_height_for_width --> get_request_mode() c.) get_desired_size(), get_desired_width(), get_desired_height() --> get_size(), get_width(), get_height() This is the first partial commit and only effects portions of the tree that have already been merged in master (in order to easily cherry pick this commit). Conflicts: gtk/Makefile.am gtk/gtk.h gtk/gtk.symbols gtk/gtkextendedlayout.h
2010-06-18 04:11:26 +00:00
if (natural_size)
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
{
natural_size->width = nat_width;
Remove gtk_widget_get_preferred_height_and_baseline_for_width It's just a wrapper around gtk_widget_measure nowadays.
2016-11-23 17:05:09 +00:00
gtk_widget_measure (widget,
GTK_ORIENTATION_VERTICAL, nat_width,
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
NULL, &natural_size->height, NULL, NULL);
}
Mega commit to change ->get_desired_size() for ->get_desired_width/height(). This commit changes gtk_extended_layout_get_desired_size() for per dimension variants. Furthermore this commit reverts the actions done in size-groups for now as it needs a different approach. The natural width/height parameters added to aux_info have been changed for a per width cache for heights and a per height cache for widths. gtk-demo is still working, currently sizegroups are not taken into account as mentioned above - size groups need to be alerted both when the widths and heights are updated independantly and then that information needs to repropagate also to other extended layout implementors.
2010-04-13 02:21:46 +00:00
}
Added GTK_SIZE_REQUEST_CONSTANT_SIZE to GtkSizeRequestMode The constant size request mode defines a request mode where height-for-width geometry is unneeded, thus optimizing GTK+ by reducing the overall amount of requests that need to be performed and cached while resizing an interface.
2011-03-05 08:49:49 +00:00
else /* GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT or CONSTANT_SIZE */
Mega commit to change ->get_desired_size() for ->get_desired_width/height(). This commit changes gtk_extended_layout_get_desired_size() for per dimension variants. Furthermore this commit reverts the actions done in size-groups for now as it needs a different approach. The natural width/height parameters added to aux_info have been changed for a per width cache for heights and a per height cache for widths. gtk-demo is still working, currently sizegroups are not taken into account as mentioned above - size groups need to be alerted both when the widths and heights are updated independantly and then that information needs to repropagate also to other extended layout implementors.
2010-04-13 02:21:46 +00:00
{
Remove gtk_widget_get_preferred_height_and_baseline_for_width It's just a wrapper around gtk_widget_measure nowadays.
2016-11-23 17:05:09 +00:00
gtk_widget_measure (widget, GTK_ORIENTATION_VERTICAL,
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
-1, &min_height, &nat_height, NULL, NULL);
Mass api change from GtkExtendedLayout --> GtkSizeRequest This commit makes a few massive changes to the extended layout code: a.) gtkextendedlayout.c --> gtksizerequest.c b.) _is_height_for_width --> get_request_mode() c.) get_desired_size(), get_desired_width(), get_desired_height() --> get_size(), get_width(), get_height() This is the first partial commit and only effects portions of the tree that have already been merged in master (in order to easily cherry pick this commit). Conflicts: gtk/Makefile.am gtk/gtk.h gtk/gtk.symbols gtk/gtkextendedlayout.h
2010-06-18 04:11:26 +00:00
if (minimum_size)
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
{
minimum_size->height = min_height;
Remove gtk_widget_get_preferred_* They are unnecessary now that we have gtk_widget_measure.
2017-05-02 19:50:50 +00:00
gtk_widget_measure (widget, GTK_ORIENTATION_HORIZONTAL, min_height,
&minimum_size->width, NULL, NULL, NULL);
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
}
Mass api change from GtkExtendedLayout --> GtkSizeRequest This commit makes a few massive changes to the extended layout code: a.) gtkextendedlayout.c --> gtksizerequest.c b.) _is_height_for_width --> get_request_mode() c.) get_desired_size(), get_desired_width(), get_desired_height() --> get_size(), get_width(), get_height() This is the first partial commit and only effects portions of the tree that have already been merged in master (in order to easily cherry pick this commit). Conflicts: gtk/Makefile.am gtk/gtk.h gtk/gtk.symbols gtk/gtkextendedlayout.h
2010-06-18 04:11:26 +00:00
if (natural_size)
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
{
natural_size->height = nat_height;
Remove gtk_widget_get_preferred_* They are unnecessary now that we have gtk_widget_measure.
2017-05-02 19:50:50 +00:00
gtk_widget_measure (widget, GTK_ORIENTATION_HORIZONTAL, nat_height,
NULL, &natural_size->width, NULL, NULL);
sizerequest: Remove _gtk_widget_get_preferred_size_and_baseline Private and unused function.
2020-01-06 09:22:54 +00:00
}
Mega commit to change ->get_desired_size() for ->get_desired_width/height(). This commit changes gtk_extended_layout_get_desired_size() for per dimension variants. Furthermore this commit reverts the actions done in size-groups for now as it needs a different approach. The natural width/height parameters added to aux_info have been changed for a per width cache for heights and a per height cache for widths. gtk-demo is still working, currently sizegroups are not taken into account as mentioned above - size groups need to be alerted both when the widths and heights are updated independantly and then that information needs to repropagate also to other extended layout implementors.
2010-04-13 02:21:46 +00:00
}
}
Added gtk_distribute_allocation() Added a convenience api for containers to use when allocating children (used to distribute space evenly to children).
2010-08-05 16:45:48 +00:00
static gint
compare_gap (gconstpointer p1,
gconstpointer p2,
gpointer data)
{
GtkRequestedSize *sizes = data;
const guint *c1 = p1;
const guint *c2 = p2;
const gint d1 = MAX (sizes[*c1].natural_size -
sizes[*c1].minimum_size,
0);
const gint d2 = MAX (sizes[*c2].natural_size -
sizes[*c2].minimum_size,
0);
gint delta = (d2 - d1);
if (0 == delta)
delta = (*c2 - *c1);
return delta;
}
/**
GtkWidget/GtkContainer: Slight fixes to geometry-management docs. Replace it's with its in several places. Replace some , with . Replace some ; with . Fix some plurals. Other minor corrections.
2010-11-04 15:30:48 +00:00
* gtk_distribute_natural_allocation:
Added gtk_distribute_allocation() Added a convenience api for containers to use when allocating children (used to distribute space evenly to children).
2010-08-05 16:45:48 +00:00
* @extra_space: Extra space to redistribute among children after subtracting
* minimum sizes and any child padding from the overall allocation
* @n_requested_sizes: Number of requests to fit into the allocation
* @sizes: An array of structs with a client pointer and a minimum/natural size
* in the orientation of the allocation.
*
GtkWidget/GtkContainer: Slight fixes to geometry-management docs. Replace it's with its in several places. Replace some , with . Replace some ; with . Fix some plurals. Other minor corrections.
2010-11-04 15:30:48 +00:00
* Distributes @extra_space to child @sizes by bringing smaller
Added gtk_distribute_allocation() Added a convenience api for containers to use when allocating children (used to distribute space evenly to children).
2010-08-05 16:45:48 +00:00
* children up to natural size first.
*
* The remaining space will be added to the @minimum_size member of the
* GtkRequestedSize struct. If all sizes reach their natural size then
* the remaining space is returned.
*
* Returns: The remainder of @extra_space after redistributing space
* to @sizes.
*/
GtkWidget/GtkContainer: Slight fixes to geometry-management docs. Replace it's with its in several places. Replace some , with . Replace some ; with . Fix some plurals. Other minor corrections.
2010-11-04 15:30:48 +00:00
gint
Added gtk_distribute_allocation() Added a convenience api for containers to use when allocating children (used to distribute space evenly to children).
2010-08-05 16:45:48 +00:00
gtk_distribute_natural_allocation (gint extra_space,
guint n_requested_sizes,
GtkRequestedSize *sizes)
{
Fixed gtk_distribute_natural_allocation() to place the g_newa *after* g_return_if_fail() guards.
2010-09-22 04:57:35 +00:00
guint *spreading;
Added gtk_distribute_allocation() Added a convenience api for containers to use when allocating children (used to distribute space evenly to children).
2010-08-05 16:45:48 +00:00
gint i;
Added return_if_fail guard to gtk_distribute_natural_allocation()
2010-08-18 23:31:53 +00:00
g_return_val_if_fail (extra_space >= 0, 0);
Fixed gtk_distribute_natural_allocation() to place the g_newa *after* g_return_if_fail() guards.
2010-09-22 04:57:35 +00:00
spreading = g_newa (guint, n_requested_sizes);
Added gtk_distribute_allocation() Added a convenience api for containers to use when allocating children (used to distribute space evenly to children).
2010-08-05 16:45:48 +00:00
for (i = 0; i < n_requested_sizes; i++)
spreading[i] = i;
/* Distribute the container's extra space c_gap. We want to assign
* this space such that the sum of extra space assigned to children
* (c^i_gap) is equal to c_cap. The case that there's not enough
* space for all children to take their natural size needs some
* attention. The goals we want to achieve are:
*
* a) Maximize number of children taking their natural size.
* b) The allocated size of children should be a continuous
* function of c_gap. That is, increasing the container size by
* one pixel should never make drastic changes in the distribution.
* c) If child i takes its natural size and child j doesn't,
* child j should have received at least as much gap as child i.
*
* The following code distributes the additional space by following
* these rules.
*/
GtkWidget/GtkContainer: Slight fixes to geometry-management docs. Replace it's with its in several places. Replace some , with . Replace some ; with . Fix some plurals. Other minor corrections.
2010-11-04 15:30:48 +00:00
Added gtk_distribute_allocation() Added a convenience api for containers to use when allocating children (used to distribute space evenly to children).
2010-08-05 16:45:48 +00:00
/* Sort descending by gap and position. */
g_qsort_with_data (spreading,
n_requested_sizes, sizeof (guint),
compare_gap, sizes);
GtkWidget/GtkContainer: Slight fixes to geometry-management docs. Replace it's with its in several places. Replace some , with . Replace some ; with . Fix some plurals. Other minor corrections.
2010-11-04 15:30:48 +00:00
Added gtk_distribute_allocation() Added a convenience api for containers to use when allocating children (used to distribute space evenly to children).
2010-08-05 16:45:48 +00:00
/* Distribute available space.
* This master piece of a loop was conceived by Behdad Esfahbod.
*/
for (i = n_requested_sizes - 1; extra_space > 0 && i >= 0; --i)
{
/* Divide remaining space by number of remaining children.
* Sort order and reducing remaining space by assigned space
* ensures that space is distributed equally.
*/
gint glue = (extra_space + i) / (i + 1);
gint gap = sizes[(spreading[i])].natural_size
- sizes[(spreading[i])].minimum_size;
GtkWidget/GtkContainer: Slight fixes to geometry-management docs. Replace it's with its in several places. Replace some , with . Replace some ; with . Fix some plurals. Other minor corrections.
2010-11-04 15:30:48 +00:00
Added gtk_distribute_allocation() Added a convenience api for containers to use when allocating children (used to distribute space evenly to children).
2010-08-05 16:45:48 +00:00
gint extra = MIN (glue, gap);
GtkWidget/GtkContainer: Slight fixes to geometry-management docs. Replace it's with its in several places. Replace some , with . Replace some ; with . Fix some plurals. Other minor corrections.
2010-11-04 15:30:48 +00:00
Added gtk_distribute_allocation() Added a convenience api for containers to use when allocating children (used to distribute space evenly to children).
2010-08-05 16:45:48 +00:00
sizes[spreading[i]].minimum_size += extra;
GtkWidget/GtkContainer: Slight fixes to geometry-management docs. Replace it's with its in several places. Replace some , with . Replace some ; with . Fix some plurals. Other minor corrections.
2010-11-04 15:30:48 +00:00
Added gtk_distribute_allocation() Added a convenience api for containers to use when allocating children (used to distribute space evenly to children).
2010-08-05 16:45:48 +00:00
extra_space -= extra;
}
return extra_space;
}
Reference in New Issue Copy Permalink