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

708 lines
25 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"
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: Honor css min size
2017-05-03 17:23:35 +00:00
static gint
get_number (GtkCssStyle *style,
guint property)
{
double d = _gtk_css_number_value_get (gtk_css_style_get_value (style, property), 100);
if (d < 1)
return ceil (d);
else
return floor (d);
}
static void
get_box_margin (GtkCssStyle *style,
GtkBorder *margin)
{
margin->top = get_number (style, GTK_CSS_PROPERTY_MARGIN_TOP);
margin->left = get_number (style, GTK_CSS_PROPERTY_MARGIN_LEFT);
margin->bottom = get_number (style, GTK_CSS_PROPERTY_MARGIN_BOTTOM);
margin->right = get_number (style, GTK_CSS_PROPERTY_MARGIN_RIGHT);
}
static void
get_box_border (GtkCssStyle *style,
GtkBorder *border)
{
border->top = get_number (style, GTK_CSS_PROPERTY_BORDER_TOP_WIDTH);
border->left = get_number (style, GTK_CSS_PROPERTY_BORDER_LEFT_WIDTH);
border->bottom = get_number (style, GTK_CSS_PROPERTY_BORDER_BOTTOM_WIDTH);
border->right = get_number (style, GTK_CSS_PROPERTY_BORDER_RIGHT_WIDTH);
}
static void
get_box_padding (GtkCssStyle *style,
GtkBorder *border)
{
border->top = get_number (style, GTK_CSS_PROPERTY_PADDING_TOP);
border->left = get_number (style, GTK_CSS_PROPERTY_PADDING_LEFT);
border->bottom = get_number (style, GTK_CSS_PROPERTY_PADDING_BOTTOM);
border->right = get_number (style, GTK_CSS_PROPERTY_PADDING_RIGHT);
}
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
{
sizerequestcache: Move lookup function ...and clean up its API.
2012-11-14 00:10:21 +00:00
SizeRequestCache *cache;
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
GtkWidgetClass *widget_class;
sizerequestcache: Move lookup function ...and clean up its API.
2012-11-14 00:10:21 +00:00
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;
sizerequest: Fix min size with widget margins
2017-05-18 10:16:35 +00:00
GtkCssStyle *style;
GtkBorder margin, border, padding;
int css_min_size;
int css_min_for_size;
int css_extra_for_size;
int css_extra_size;
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: 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
if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_CONSTANT_SIZE)
for_size = -1;
sizerequestcache: Move lookup function ...and clean up its API.
2012-11-14 00:10:21 +00:00
cache = _gtk_widget_peek_request_cache (widget);
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
widget_class = GTK_WIDGET_GET_CLASS (widget);
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
if (!found_in_cache)
{
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: 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);
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;
css_min_size = get_number (style, GTK_CSS_PROPERTY_MIN_WIDTH);
css_min_for_size = get_number (style, GTK_CSS_PROPERTY_MIN_HEIGHT);
}
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;
css_min_size = get_number (style, GTK_CSS_PROPERTY_MIN_HEIGHT);
css_min_for_size = get_number (style, GTK_CSS_PROPERTY_MIN_WIDTH);
}
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 (for_size < 0)
Formatting and typo fixes
2010-04-24 01:52:55 +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
push_recursion_check (widget, orientation);
widget_class->measure (widget, orientation, -1,
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
&reported_min_size, &reported_nat_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
&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
{
sizerequest: Fix for_size adjustment We need to pull the proper size from the size request cache and adjust it accordingly.
2018-01-17 14:42:01 +00:00
int adjusted_for_size;
sizerequest: Don't pass uninitialized values to measure The GtkWidgetClass::measure vfunc is not required to assign a value to any of the (out) parameters, so we need to initialize the locals we pass to it, otherwise we can end up with a garbage size request.
2017-10-28 09:37:13 +00:00
int minimum_for_size = 0;
int natural_for_size = 0;
sizerequest: Fix for_size adjustment We need to pull the proper size from the size request cache and adjust it accordingly.
2018-01-17 14:42:01 +00:00
int dummy = 0;
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
sizerequest: Fix for_size adjustment We need to pull the proper size from the size request cache and adjust it accordingly.
2018-01-17 14:42:01 +00:00
/* Pull the minimum for_size from the cache as it's needed to adjust
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
* the proposed 'for_size' */
sizerequest: Fix for_size adjustment We need to pull the proper size from the size request cache and adjust it accordingly.
2018-01-17 14:42:01 +00:00
gtk_widget_measure (widget, OPPOSITE_ORIENTATION (orientation), -1,
&minimum_for_size, &natural_for_size, NULL, NULL);
sizerequest: Fix min size with widget margins
2017-05-18 10:16:35 +00:00
/* TODO: Warn if the given for_size is too small? */
sizerequest: Fix for_size adjustment We need to pull the proper size from the size request cache and adjust it accordingly.
2018-01-17 14:42:01 +00:00
if (for_size < MAX (minimum_for_size, css_min_for_size))
for_size = MAX (minimum_for_size, css_min_for_size);
adjusted_for_size = for_size;
gtk_widget_adjust_size_allocation (widget, OPPOSITE_ORIENTATION (orientation),
&for_size, &natural_for_size,
&dummy, &adjusted_for_size);
sizerequest: Fix min size with widget margins
2017-05-18 10:16:35 +00:00
sizerequest: Fix for_size adjustment We need to pull the proper size from the size request cache and adjust it accordingly.
2018-01-17 14:42:01 +00:00
adjusted_for_size -= css_extra_for_size;
sizerequest: Fix min size with widget margins
2017-05-18 10:16:35 +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
push_recursion_check (widget, orientation);
widget_class->measure (widget,
orientation,
sizerequest: Fix min size with widget margins
2017-05-18 10:16:35 +00:00
adjusted_for_size,
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
&reported_min_size, &reported_nat_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
&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,
gtk_css_node_get_name (gtk_widget_get_css_node (widget)),
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,
gtk_css_node_get_name (gtk_widget_get_css_node (widget)),
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,
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
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
}
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)
{
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
Make geometry logging per-display Use the new macro to do this.
2018-01-14 14:55:32 +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.
* As an example, if @orientation is GTK_ORIENTATION_HORIZONTAL and @for_size is 300,
* 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
{
GHashTable *widgets;
GHashTableIter iter;
gpointer key;
gint min_result = 0, nat_result = 0;
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.
*/
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
if (!_gtk_widget_get_visible (widget) && !_gtk_widget_is_toplevel (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
return;
}
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: 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
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
g_hash_table_iter_init (&iter, widgets);
while (g_hash_table_iter_next (&iter, &key, NULL))
{
GtkWidget *tmp_widget = key;
gint min_dimension, nat_dimension;
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 (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: Fix min size with widget margins
2017-05-18 10:16:35 +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
}
g_hash_table_destroy (widgets);
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
/* Baselines make no sense with sizegroups really */
if (minimum_baseline)
*minimum_baseline = -1;
if (natural_baseline)
*natural_baseline = -1;
sizerequest: do not derefence NULL pointers
2012-11-04 16:42:55 +00:00
if (minimum)
sizerequest: Make size groups "work" We have to query the css margin/border/padding values for all widgets in the size group.
2017-05-06 12:05:30 +00:00
*minimum = min_result;
sizerequest: do not derefence NULL pointers
2012-11-04 16:42:55 +00:00
if (natural)
sizerequest: Make size groups "work" We have to query the css margin/border/padding values for all widgets in the size group.
2017-05-06 12:05:30 +00:00
*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
{
cache->request_mode = GTK_WIDGET_GET_CLASS (widget)->get_request_mode (widget);
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
}
API: Don't export gtk_widget_preferred_size_and_baseline() gtk_widget_preferred_size() is only useful if you want to quickly port a widget from GTK2 sizing code to GTK3 but does not properly work with height-for-width as used in GTK. So we don't want to encourage people to use it. In particular we want people to convert to height-for-width before adding baseline support to their widgets.
2013-05-11 12:29:29 +00:00
/*
* _gtk_widget_get_preferred_size_and_baseline:
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
*
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
* Retrieves the minimum and natural size and the corresponding baselines of a widget, taking
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* into account the widget’s preference for height-for-width management. The baselines may
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
* be -1 which means that no baseline is requested for this 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
*
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.
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
API: Don't export gtk_widget_preferred_size_and_baseline() gtk_widget_preferred_size() is only useful if you want to quickly port a widget from GTK2 sizing code to GTK3 but does not properly work with height-for-width as used in GTK. So we don't want to encourage people to use it. In particular we want people to convert to height-for-width before adding baseline support to their widgets.
2013-05-11 12:29:29 +00:00
_gtk_widget_get_preferred_size_and_baseline (GtkWidget *widget,
GtkRequisition *minimum_size,
GtkRequisition *natural_size,
gint *minimum_baseline,
gint *natural_baseline)
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
{
gint min_width, nat_width;
gint min_height, nat_height;
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)
{
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,
&minimum_size->height, NULL, minimum_baseline, 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)
{
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,
NULL, &natural_size->height, NULL, natural_baseline);
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
}
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,
-1, &min_height, &nat_height, minimum_baseline, natural_baseline);
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)
{
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);
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)
{
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);
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
}
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
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_get_preferred_size:
* @widget: a #GtkWidget instance
* @minimum_size: (out) (allow-none): location for storing the minimum size, or %NULL
* @natural_size: (out) (allow-none): location for storing the natural size, or %NULL
*
* Retrieves the minimum and natural size of a widget, taking
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* into account the widget’s preference for height-for-width management.
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
*
* This is used to retrieve a suitable size by container widgets which do
* 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
* free-form containers such as GtkLayout.
*
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
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
* 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.
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
*
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
* Use gtk_widget_measure() if you want to support
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
* baseline alignment.
*/
void
gtk_widget_get_preferred_size (GtkWidget *widget,
GtkRequisition *minimum_size,
GtkRequisition *natural_size)
{
API: Don't export gtk_widget_preferred_size_and_baseline() gtk_widget_preferred_size() is only useful if you want to quickly port a widget from GTK2 sizing code to GTK3 but does not properly work with height-for-width as used in GTK. So we don't want to encourage people to use it. In particular we want people to convert to height-for-width before adding baseline support to their widgets.
2013-05-11 12:29:29 +00:00
_gtk_widget_get_preferred_size_and_baseline (widget, minimum_size, natural_size,
NULL, NULL);
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
}
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