From: Timm Bäder Date: Wed, 11 Sep 2019 11:11:02 +0000 (+0200) Subject: Add GtkCenterLayout X-Git-Tag: archive/raspbian/4.4.1+ds1-2+rpi1^2~18^2~20^2~859 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=a7b9a33efca57170addce4a46f9634b2b6c85d06;p=gtk4.git Add GtkCenterLayout And use it in GtkCenterBox, different widgets following. --- diff --git a/docs/reference/gtk/gtk4-sections.txt b/docs/reference/gtk/gtk4-sections.txt index c695c07cfa..b454df5ca1 100644 --- a/docs/reference/gtk/gtk4-sections.txt +++ b/docs/reference/gtk/gtk4-sections.txt @@ -341,6 +341,30 @@ GTK_CENTER_BOX_GET_CLASS gtk_center_box_get_type +
+gtkcenterlayout +GtkCenterLayout +GtkCenterLayout +gtk_center_layout_new +gtk_center_layout_set_start_widget +gtk_center_layout_set_center_widget +gtk_center_layout_set_end_widget +gtk_center_layout_get_start_widget +gtk_center_layout_get_center_widget +gtk_center_layout_get_end_widget +gtk_center_layout_set_baseline_position +gtk_center_layout_get_baseline_position + +GTK_TYPE_CENTER_layout +GTK_CENTER_LAYOUT +GTK_CENTER_LAYOUT_CLASS +GTK_IS_CENTER_LAYOUT +GTK_IS_CENTER_LAYOUT_CLASS +GTK_CENTER_LAYOUT_GET_CLASS + +gtk_center_layout_get_type +
+
gtklistbox GtkListBox diff --git a/gtk/gtk.h b/gtk/gtk.h index ecf4829339..29a37ff5f3 100644 --- a/gtk/gtk.h +++ b/gtk/gtk.h @@ -73,6 +73,7 @@ #include #include #include +#include #include #include #include diff --git a/gtk/gtkcenterbox.c b/gtk/gtkcenterbox.c index b808cababc..8bd0a7fda0 100644 --- a/gtk/gtkcenterbox.c +++ b/gtk/gtkcenterbox.c @@ -54,6 +54,7 @@ #include "config.h" #include "gtkcenterbox.h" +#include "gtkcenterlayout.h" #include "gtkcssnodeprivate.h" #include "gtkwidgetprivate.h" #include "gtkorientable.h" @@ -71,9 +72,6 @@ struct _GtkCenterBox GtkWidget *start_widget; GtkWidget *center_widget; GtkWidget *end_widget; - - GtkOrientation orientation; - GtkBaselinePosition baseline_pos; }; struct _GtkCenterBoxClass @@ -120,446 +118,6 @@ gtk_center_box_buildable_init (GtkBuildableIface *iface) iface->add_child = gtk_center_box_buildable_add_child; } -static gboolean -get_expand (GtkWidget *widget, - GtkOrientation orientation) -{ - if (orientation == GTK_ORIENTATION_HORIZONTAL) - return gtk_widget_get_hexpand (widget); - else - return gtk_widget_get_vexpand (widget); -} - -static void -gtk_center_box_distribute (GtkCenterBox *self, - gint for_size, - gint size, - GtkRequestedSize *sizes) -{ - int center_size = 0; - int start_size = 0; - int end_size = 0; - gboolean center_expand = FALSE; - gboolean start_expand = FALSE; - gboolean end_expand = FALSE; - int avail; - - sizes[0].minimum_size = sizes[0].natural_size = 0; - sizes[1].minimum_size = sizes[1].natural_size = 0; - sizes[2].minimum_size = sizes[2].natural_size = 0; - - if (self->start_widget) - gtk_widget_measure (self->start_widget, - self->orientation, - for_size, - &sizes[0].minimum_size, &sizes[0].natural_size, - NULL, NULL); - - if (self->center_widget) - gtk_widget_measure (self->center_widget, - self->orientation, - for_size, - &sizes[1].minimum_size, &sizes[1].natural_size, - NULL, NULL); - - - if (self->end_widget) - gtk_widget_measure (self->end_widget, - self->orientation, - for_size, - &sizes[2].minimum_size, &sizes[2].natural_size, - NULL, NULL); - - if (self->center_widget) - { - center_size = CLAMP (size - (sizes[0].minimum_size + sizes[2].minimum_size), sizes[1].minimum_size, sizes[1].natural_size); - center_expand = get_expand (self->center_widget, self->orientation); - } - - if (self->start_widget) - { - avail = MIN ((size - center_size) / 2, size - (center_size + sizes[2].minimum_size)); - start_size = CLAMP (avail, sizes[0].minimum_size, sizes[0].natural_size); - start_expand = get_expand (self->start_widget, self->orientation); - } - - if (self->end_widget) - { - avail = MIN ((size - center_size) / 2, size - (center_size + sizes[0].minimum_size)); - end_size = CLAMP (avail, sizes[2].minimum_size, sizes[2].natural_size); - end_expand = get_expand (self->end_widget, self->orientation); - } - - if (self->center_widget) - { - int center_pos; - - center_pos = (size / 2) - (center_size / 2); - - /* Push in from start/end */ - if (start_size > center_pos) - center_pos = start_size; - else if (size - end_size < center_pos + center_size) - center_pos = size - center_size - end_size; - else if (center_expand) - { - center_size = size - 2 * MAX (start_size, end_size); - center_pos = (size / 2) - (center_size / 2); - } - - if (start_expand) - start_size = center_pos; - - if (end_expand) - end_size = size - (center_pos + center_size); - } - else - { - avail = size - (start_size + end_size); - if (start_expand && end_expand) - { - start_size += avail / 2; - end_size += avail / 2; - } - else if (start_expand) - { - start_size += avail; - } - else if (end_expand) - { - end_size += avail; - } - } - - sizes[0].minimum_size = start_size; - sizes[1].minimum_size = center_size; - sizes[2].minimum_size = end_size; -} - -static void -gtk_center_box_measure_orientation (GtkWidget *widget, - GtkOrientation orientation, - int for_size, - int *minimum, - int *natural, - int *minimum_baseline, - int *natural_baseline) -{ - GtkCenterBox *self = GTK_CENTER_BOX (widget); - int min_baseline, nat_baseline; - int start_min = 0; - int start_nat = 0; - int center_min = 0; - int center_nat = 0; - int end_min = 0; - int end_nat = 0; - - if (self->start_widget) - gtk_widget_measure (self->start_widget, - orientation, - for_size, - &start_min, &start_nat, - &min_baseline, &nat_baseline); - - if (self->center_widget) - gtk_widget_measure (self->center_widget, - orientation, - for_size, - ¢er_min, ¢er_nat, - &min_baseline, &nat_baseline); - - if (self->end_widget) - gtk_widget_measure (self->end_widget, - orientation, - for_size, - &end_min, &end_nat, - &min_baseline, &nat_baseline); - - *minimum = start_min + center_min + end_min; - *natural = center_nat + 2 * MAX (start_nat, end_nat); -} - -static void -gtk_center_box_measure_opposite (GtkWidget *widget, - GtkOrientation orientation, - int for_size, - int *minimum, - int *natural, - int *minimum_baseline, - int *natural_baseline) -{ - GtkCenterBox *self = GTK_CENTER_BOX (widget); - int child_min, child_nat; - int child_min_baseline, child_nat_baseline; - int total_min, above_min, below_min; - int total_nat, above_nat, below_nat; - GtkWidget *child[3]; - GtkRequestedSize sizes[3]; - int i; - - child[0] = self->start_widget; - child[1] = self->center_widget; - child[2] = self->end_widget; - - if (for_size >= 0) - gtk_center_box_distribute (self, -1, for_size, sizes); - - above_min = below_min = above_nat = below_nat = -1; - total_min = total_nat = 0; - - for (i = 0; i < 3; i++) - { - if (child[i] == NULL) - continue; - - gtk_widget_measure (child[i], - orientation, - for_size >= 0 ? sizes[i].minimum_size : -1, - &child_min, &child_nat, - &child_min_baseline, &child_nat_baseline); - - if (child_min_baseline >= 0) - { - below_min = MAX (below_min, child_min - child_min_baseline); - above_min = MAX (above_min, child_min_baseline); - below_nat = MAX (below_nat, child_nat - child_nat_baseline); - above_nat = MAX (above_nat, child_nat_baseline); - } - else - { - total_min = MAX (total_min, child_min); - total_nat = MAX (total_nat, child_nat); - } - } - - if (above_min >= 0) - { - int min_baseline = -1; - int nat_baseline = -1; - - total_min = MAX (total_min, above_min + below_min); - total_nat = MAX (total_nat, above_nat + below_nat); - - switch (self->baseline_pos) - { - case GTK_BASELINE_POSITION_TOP: - min_baseline = above_min; - nat_baseline = above_nat; - break; - case GTK_BASELINE_POSITION_CENTER: - min_baseline = above_min + (total_min - (above_min + below_min)) / 2; - nat_baseline = above_nat + (total_nat - (above_nat + below_nat)) / 2; - break; - case GTK_BASELINE_POSITION_BOTTOM: - min_baseline = total_min - below_min; - nat_baseline = total_nat - below_nat; - break; - default: - break; - } - - if (minimum_baseline) - *minimum_baseline = min_baseline; - if (natural_baseline) - *natural_baseline = nat_baseline; - } - - *minimum = total_min; - *natural = total_nat; -} - -static void -gtk_center_box_measure (GtkWidget *widget, - GtkOrientation orientation, - int for_size, - int *minimum, - int *natural, - int *minimum_baseline, - int *natural_baseline) -{ - GtkCenterBox *self = GTK_CENTER_BOX (widget); - - if (self->orientation == orientation) - gtk_center_box_measure_orientation (widget, orientation, for_size, minimum, natural, minimum_baseline, natural_baseline); - else - gtk_center_box_measure_opposite (widget, orientation, for_size, minimum, natural, minimum_baseline, natural_baseline); -} - -static void -gtk_center_box_size_allocate (GtkWidget *widget, - int width, - int height, - int baseline) -{ - GtkCenterBox *self = GTK_CENTER_BOX (widget); - GtkAllocation child_allocation; - GtkWidget *child[3]; - int child_size[3]; - int child_pos[3]; - GtkRequestedSize sizes[3]; - int size; - int for_size; - int i; - - if (self->orientation == GTK_ORIENTATION_HORIZONTAL) - { - size = width; - for_size = height; - } - else - { - size = height; - for_size = width; - baseline = -1; - } - - /* Allocate child sizes */ - - gtk_center_box_distribute (self, for_size, size, sizes); - - if (self->orientation == GTK_ORIENTATION_HORIZONTAL && - gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) - { - child[0] = self->end_widget; - child[1] = self->center_widget; - child[2] = self->start_widget; - child_size[0] = sizes[2].minimum_size; - child_size[1] = sizes[1].minimum_size; - child_size[2] = sizes[0].minimum_size; - } - else - { - child[0] = self->start_widget; - child[1] = self->center_widget; - child[2] = self->end_widget; - child_size[0] = sizes[0].minimum_size; - child_size[1] = sizes[1].minimum_size; - child_size[2] = sizes[2].minimum_size; - } - - /* Determine baseline */ - if (self->orientation == GTK_ORIENTATION_HORIZONTAL && - baseline == -1) - { - int min_above, nat_above; - int min_below, nat_below; - gboolean have_baseline; - - have_baseline = FALSE; - min_above = nat_above = 0; - min_below = nat_below = 0; - - for (i = 0; i < 3; i++) - { - if (child[i] && gtk_widget_get_valign (child[i]) == GTK_ALIGN_BASELINE) - { - int child_min_height, child_nat_height; - int child_min_baseline, child_nat_baseline; - - child_min_baseline = child_nat_baseline = -1; - - gtk_widget_measure (child[i], GTK_ORIENTATION_VERTICAL, - child_size[i], - &child_min_height, &child_nat_height, - &child_min_baseline, &child_nat_baseline); - - if (child_min_baseline >= 0) - { - have_baseline = TRUE; - min_below = MAX (min_below, child_min_height - child_min_baseline); - nat_below = MAX (nat_below, child_nat_height - child_nat_baseline); - min_above = MAX (min_above, child_min_baseline); - nat_above = MAX (nat_above, child_nat_baseline); - } - } - } - - if (have_baseline) - { - /* TODO: This is purely based on the minimum baseline. - * When things fit we should use the natural one - */ - switch (self->baseline_pos) - { - default: - case GTK_BASELINE_POSITION_TOP: - baseline = min_above; - break; - case GTK_BASELINE_POSITION_CENTER: - baseline = min_above + (height - (min_above + min_below)) / 2; - break; - case GTK_BASELINE_POSITION_BOTTOM: - baseline = height - min_below; - break; - } - } - } - - /* Allocate child positions */ - - child_pos[0] = 0; - child_pos[1] = (size / 2) - (child_size[1] / 2); - child_pos[2] = size - child_size[2]; - - if (child[1]) - { - /* Push in from start/end */ - if (child_size[0] > child_pos[1]) - child_pos[1] = child_size[0]; - else if (size - child_size[2] < child_pos[1] + child_size[1]) - child_pos[1] = size - child_size[1] - child_size[2]; - } - - child_allocation = (GtkAllocation) { 0, 0, width, height }; - - for (i = 0; i < 3; i++) - { - if (child[i] == NULL) - continue; - - if (self->orientation == GTK_ORIENTATION_HORIZONTAL) - { - child_allocation.x = child_pos[i]; - child_allocation.y = 0; - child_allocation.width = child_size[i]; - child_allocation.height = height; - } - else - { - child_allocation.x = 0; - child_allocation.y = child_pos[i]; - child_allocation.width = width; - child_allocation.height = child_size[i]; - } - - gtk_widget_size_allocate (child[i], &child_allocation, baseline); - } -} - -static GtkSizeRequestMode -gtk_center_box_get_request_mode (GtkWidget *widget) -{ - GtkCenterBox *self = GTK_CENTER_BOX (widget); - gint count[3] = { 0, 0, 0 }; - - if (self->start_widget) - count[gtk_widget_get_request_mode (self->start_widget)]++; - - if (self->center_widget) - count[gtk_widget_get_request_mode (self->center_widget)]++; - - if (self->end_widget) - count[gtk_widget_get_request_mode (self->end_widget)]++; - - if (!count[GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH] && - !count[GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT]) - return GTK_SIZE_REQUEST_CONSTANT_SIZE; - else - return count[GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT] > count[GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH] - ? GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT - : GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH; -} - static void gtk_center_box_set_property (GObject *object, guint prop_id, @@ -567,6 +125,7 @@ gtk_center_box_set_property (GObject *object, GParamSpec *pspec) { GtkCenterBox *self = GTK_CENTER_BOX (object); + GtkLayoutManager *layout = gtk_widget_get_layout_manager (GTK_WIDGET (object)); switch (prop_id) { @@ -577,9 +136,10 @@ gtk_center_box_set_property (GObject *object, case PROP_ORIENTATION: { GtkOrientation orientation = g_value_get_enum (value); - if (self->orientation != orientation) + GtkOrientation current = gtk_center_layout_get_orientation (GTK_CENTER_LAYOUT (layout)); + if (current != orientation) { - self->orientation = orientation; + gtk_center_layout_set_orientation (GTK_CENTER_LAYOUT (layout), orientation); _gtk_orientable_set_style_classes (GTK_ORIENTABLE (self)); gtk_widget_queue_resize (GTK_WIDGET (self)); g_object_notify (object, "orientation"); @@ -599,16 +159,16 @@ gtk_center_box_get_property (GObject *object, GValue *value, GParamSpec *pspec) { - GtkCenterBox *self = GTK_CENTER_BOX (object); + GtkLayoutManager *layout = gtk_widget_get_layout_manager (GTK_WIDGET (object)); switch (prop_id) { case PROP_BASELINE_POSITION: - g_value_set_enum (value, self->baseline_pos); + g_value_set_enum (value, gtk_center_layout_get_baseline_position (GTK_CENTER_LAYOUT (layout))); break; case PROP_ORIENTATION: - g_value_set_enum (value, self->orientation); + g_value_set_enum (value, gtk_center_layout_get_orientation (GTK_CENTER_LAYOUT (layout))); break; default: @@ -639,10 +199,6 @@ gtk_center_box_class_init (GtkCenterBoxClass *klass) object_class->get_property = gtk_center_box_get_property; object_class->dispose = gtk_center_box_dispose; - widget_class->measure = gtk_center_box_measure; - widget_class->size_allocate = gtk_center_box_size_allocate; - widget_class->get_request_mode = gtk_center_box_get_request_mode; - g_object_class_override_property (object_class, PROP_ORIENTATION, "orientation"); g_object_class_install_property (object_class, PROP_BASELINE_POSITION, @@ -655,6 +211,7 @@ gtk_center_box_class_init (GtkCenterBoxClass *klass) gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_FILLER); + gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_CENTER_LAYOUT); gtk_widget_class_set_css_name (widget_class, I_("box")); } @@ -664,9 +221,6 @@ gtk_center_box_init (GtkCenterBox *self) self->start_widget = NULL; self->center_widget = NULL; self->end_widget = NULL; - - self->orientation = GTK_ORIENTATION_HORIZONTAL; - self->baseline_pos = GTK_BASELINE_POSITION_CENTER; } /** @@ -693,12 +247,17 @@ void gtk_center_box_set_start_widget (GtkCenterBox *self, GtkWidget *child) { + GtkLayoutManager *layout_manager; + if (self->start_widget) gtk_widget_unparent (self->start_widget); self->start_widget = child; if (child) gtk_widget_insert_after (child, GTK_WIDGET (self), NULL); + + layout_manager = gtk_widget_get_layout_manager (GTK_WIDGET (self)); + gtk_center_layout_set_start_widget (GTK_CENTER_LAYOUT (layout_manager), child); } /** @@ -712,12 +271,17 @@ void gtk_center_box_set_center_widget (GtkCenterBox *self, GtkWidget *child) { + GtkLayoutManager *layout_manager; + if (self->center_widget) gtk_widget_unparent (self->center_widget); self->center_widget = child; if (child) gtk_widget_insert_after (child, GTK_WIDGET (self), self->start_widget); + + layout_manager = gtk_widget_get_layout_manager (GTK_WIDGET (self)); + gtk_center_layout_set_center_widget (GTK_CENTER_LAYOUT (layout_manager), child); } /** @@ -731,12 +295,17 @@ void gtk_center_box_set_end_widget (GtkCenterBox *self, GtkWidget *child) { + GtkLayoutManager *layout_manager; + if (self->end_widget) gtk_widget_unparent (self->end_widget); self->end_widget = child; if (child) gtk_widget_insert_before (child, GTK_WIDGET (self), NULL); + + layout_manager = gtk_widget_get_layout_manager (GTK_WIDGET (self)); + gtk_center_layout_set_end_widget (GTK_CENTER_LAYOUT (layout_manager), child); } /** @@ -798,11 +367,16 @@ void gtk_center_box_set_baseline_position (GtkCenterBox *self, GtkBaselinePosition position) { + GtkBaselinePosition current_position; + GtkLayoutManager *layout; + g_return_if_fail (GTK_IS_CENTER_BOX (self)); - if (self->baseline_pos != position) + layout = gtk_widget_get_layout_manager (GTK_WIDGET (self)); + current_position = gtk_center_layout_get_baseline_position (GTK_CENTER_LAYOUT (layout)); + if (current_position != position) { - self->baseline_pos = position; + gtk_center_layout_set_baseline_position (GTK_CENTER_LAYOUT (layout), position); g_object_notify (G_OBJECT (self), "baseline-position"); gtk_widget_queue_resize (GTK_WIDGET (self)); } @@ -819,8 +393,12 @@ gtk_center_box_set_baseline_position (GtkCenterBox *self, GtkBaselinePosition gtk_center_box_get_baseline_position (GtkCenterBox *self) { + GtkLayoutManager *layout; + g_return_val_if_fail (GTK_IS_CENTER_BOX (self), GTK_BASELINE_POSITION_CENTER); - return self->baseline_pos; + layout = gtk_widget_get_layout_manager (GTK_WIDGET (self)); + + return gtk_center_layout_get_baseline_position (GTK_CENTER_LAYOUT (layout)); } diff --git a/gtk/gtkcenterlayout.c b/gtk/gtkcenterlayout.c new file mode 100644 index 0000000000..b4d8a79fac --- /dev/null +++ b/gtk/gtkcenterlayout.c @@ -0,0 +1,686 @@ +/* + * SPDX-License-Identifier: LGPL-2.1-or-later + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see . + */ +#include "config.h" + +#include "gtkcenterlayout.h" + +#include "gtkcsspositionvalueprivate.h" +#include "gtkintl.h" +#include "gtklayoutchild.h" +#include "gtkprivate.h" +#include "gtksizerequest.h" +#include "gtkstylecontextprivate.h" +#include "gtkwidgetprivate.h" + +/** + * SECTION:gtkcenterlayout + * @Title: GtkCenterLayout + * @Short_description: A centering layout + * + * A #GtkCenterLayout is a layout manager that manages up to three children. + * The start widget is allocated at the start of the layout (left in LRT + * layouts and right in RTL ones), and the end widget at the end. + * + * The center widget is centered regarding the full width of the layout's. + */ +struct _GtkCenterLayout +{ + GtkLayoutManager parent_instance; + + GtkBaselinePosition baseline_pos; + GtkOrientation orientation; + + union { + struct { + GtkWidget *start_widget; + GtkWidget *center_widget; + GtkWidget *end_widget; + }; + GtkWidget *children[3]; + }; +}; + +G_DEFINE_TYPE (GtkCenterLayout, gtk_center_layout, GTK_TYPE_LAYOUT_MANAGER) + +static int +get_spacing (GtkCenterLayout *self, + GtkStyleContext *style_context) +{ + GtkCssValue *border_spacing; + int css_spacing; + + border_spacing = _gtk_style_context_peek_property (style_context, GTK_CSS_PROPERTY_BORDER_SPACING); + if (self->orientation == GTK_ORIENTATION_HORIZONTAL) + css_spacing = _gtk_css_position_value_get_x (border_spacing, 100); + else + css_spacing = _gtk_css_position_value_get_y (border_spacing, 100); + + return css_spacing; +} + +static GtkSizeRequestMode +gtk_center_layout_get_request_mode (GtkLayoutManager *layout_manager, + GtkWidget *widget) +{ + GtkCenterLayout *self = GTK_CENTER_LAYOUT (layout_manager); + int count[3] = { 0, 0, 0 }; + + if (self->start_widget) + count[gtk_widget_get_request_mode (self->start_widget)]++; + + if (self->center_widget) + count[gtk_widget_get_request_mode (self->center_widget)]++; + + if (self->end_widget) + count[gtk_widget_get_request_mode (self->end_widget)]++; + + if (!count[GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH] && + !count[GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT]) + return GTK_SIZE_REQUEST_CONSTANT_SIZE; + else + return count[GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT] > count[GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH] + ? GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT + : GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH; +} + +static gboolean +get_expand (GtkWidget *widget, + GtkOrientation orientation) +{ + if (orientation == GTK_ORIENTATION_HORIZONTAL) + return gtk_widget_get_hexpand (widget); + else + return gtk_widget_get_vexpand (widget); +} + +static void +gtk_center_layout_distribute (GtkCenterLayout *self, + int for_size, + int size, + int spacing, + GtkRequestedSize *sizes) +{ + int center_size = 0; + int start_size = 0; + int end_size = 0; + gboolean center_expand = FALSE; + gboolean start_expand = FALSE; + gboolean end_expand = FALSE; + int avail; + int i; + + /* Usable space is really less... */ + size -= spacing * 2; + + sizes[0].minimum_size = sizes[0].natural_size = 0; + sizes[1].minimum_size = sizes[1].natural_size = 0; + sizes[2].minimum_size = sizes[2].natural_size = 0; + + for (i = 0; i < 3; i ++) + { + if (self->children[i]) + gtk_widget_measure (self->children[i], self->orientation, for_size, + &sizes[i].minimum_size, &sizes[i].natural_size, + NULL, NULL); + } + + if (self->center_widget) + { + center_size = CLAMP (size - (sizes[0].minimum_size + sizes[2].minimum_size), sizes[1].minimum_size, sizes[1].natural_size); + center_expand = get_expand (self->center_widget, self->orientation); + } + + if (self->start_widget) + { + avail = MIN ((size - center_size) / 2, size - (center_size + sizes[2].minimum_size)); + start_size = CLAMP (avail, sizes[0].minimum_size, sizes[0].natural_size); + start_expand = get_expand (self->start_widget, self->orientation); + } + + if (self->end_widget) + { + avail = MIN ((size - center_size) / 2, size - (center_size + sizes[0].minimum_size)); + end_size = CLAMP (avail, sizes[2].minimum_size, sizes[2].natural_size); + end_expand = get_expand (self->end_widget, self->orientation); + } + + if (self->center_widget) + { + int center_pos; + + center_pos = (size / 2) - (center_size / 2); + + /* Push in from start/end */ + if (start_size > center_pos) + center_pos = start_size; + else if (size - end_size < center_pos + center_size) + center_pos = size - center_size - end_size; + else if (center_expand) + { + center_size = size - 2 * MAX (start_size, end_size); + center_pos = (size / 2) - (center_size / 2); + } + + if (start_expand) + start_size = center_pos; + + if (end_expand) + end_size = size - (center_pos + center_size); + } + else + { + avail = size - (start_size + end_size); + if (start_expand && end_expand) + { + start_size += avail / 2; + end_size += avail / 2; + } + else if (start_expand) + { + start_size += avail; + } + else if (end_expand) + { + end_size += avail; + } + } + + sizes[0].minimum_size = start_size; + sizes[1].minimum_size = center_size; + sizes[2].minimum_size = end_size; +} + +static void +gtk_center_layout_measure_orientation (GtkCenterLayout *self, + GtkWidget *widget, + GtkOrientation orientation, + int for_size, + int *minimum, + int *natural, + int *minimum_baseline, + int *natural_baseline) +{ + int min[3]; + int nat[3]; + int n_visible_children = 0; + int spacing; + int i; + + spacing = get_spacing (self, _gtk_widget_get_style_context (widget)); + + for (i = 0; i < 3; i ++) + { + GtkWidget *child = self->children[i]; + + if (child) + { + gtk_widget_measure (child, + orientation, + for_size, + &min[i], &nat[i], NULL, NULL); + + if (_gtk_widget_get_visible (child)) + n_visible_children ++; + } + else + { + min[i] = 0; + nat[i] = 0; + } + } + + *minimum = min[0] + min[1] + min[2]; + *natural = nat[1] + 2 * MAX (nat[0], nat[2]); + + if (n_visible_children > 0) + { + *minimum += (n_visible_children - 1) * spacing; + *natural += (n_visible_children - 1) * spacing; + } +} + +static void +gtk_center_layout_measure_opposite (GtkCenterLayout *self, + GtkOrientation orientation, + int for_size, + int *minimum, + int *natural, + int *minimum_baseline, + int *natural_baseline) +{ + int child_min, child_nat; + int child_min_baseline, child_nat_baseline; + int total_min, above_min, below_min; + int total_nat, above_nat, below_nat; + GtkWidget *child[3]; + GtkRequestedSize sizes[3]; + int i; + + child[0] = self->start_widget; + child[1] = self->center_widget; + child[2] = self->end_widget; + + if (for_size >= 0) + gtk_center_layout_distribute (self, -1, for_size, 0, sizes); + + above_min = below_min = above_nat = below_nat = -1; + total_min = total_nat = 0; + + for (i = 0; i < 3; i++) + { + if (child[i] == NULL) + continue; + + gtk_widget_measure (child[i], + orientation, + for_size >= 0 ? sizes[i].minimum_size : -1, + &child_min, &child_nat, + &child_min_baseline, &child_nat_baseline); + + if (child_min_baseline >= 0) + { + below_min = MAX (below_min, child_min - child_min_baseline); + above_min = MAX (above_min, child_min_baseline); + below_nat = MAX (below_nat, child_nat - child_nat_baseline); + above_nat = MAX (above_nat, child_nat_baseline); + } + else + { + total_min = MAX (total_min, child_min); + total_nat = MAX (total_nat, child_nat); + } + } + + if (above_min >= 0) + { + int min_baseline = -1; + int nat_baseline = -1; + + total_min = MAX (total_min, above_min + below_min); + total_nat = MAX (total_nat, above_nat + below_nat); + + switch (self->baseline_pos) + { + case GTK_BASELINE_POSITION_TOP: + min_baseline = above_min; + nat_baseline = above_nat; + break; + case GTK_BASELINE_POSITION_CENTER: + min_baseline = above_min + (total_min - (above_min + below_min)) / 2; + nat_baseline = above_nat + (total_nat - (above_nat + below_nat)) / 2; + break; + case GTK_BASELINE_POSITION_BOTTOM: + min_baseline = total_min - below_min; + nat_baseline = total_nat - below_nat; + break; + default: + break; + } + + if (minimum_baseline) + *minimum_baseline = min_baseline; + if (natural_baseline) + *natural_baseline = nat_baseline; + } + + *minimum = total_min; + *natural = total_nat; +} + + + +static void +gtk_center_layout_measure (GtkLayoutManager *layout_manager, + GtkWidget *widget, + GtkOrientation orientation, + int for_size, + int *minimum, + int *natural, + int *minimum_baseline, + int *natural_baseline) +{ + GtkCenterLayout *self = GTK_CENTER_LAYOUT (layout_manager); + + if (self->orientation == orientation) + gtk_center_layout_measure_orientation (self, widget, orientation, for_size, + minimum, natural, minimum_baseline, natural_baseline); + else + gtk_center_layout_measure_opposite (self, orientation, for_size, + minimum, natural, minimum_baseline, natural_baseline); +} + +static void +gtk_center_layout_allocate (GtkLayoutManager *layout_manager, + GtkWidget *widget, + int width, + int height, + int baseline) +{ + GtkCenterLayout *self = GTK_CENTER_LAYOUT (layout_manager); + GtkWidget *child[3]; + int child_size[3]; + int child_pos[3]; + GtkRequestedSize sizes[3]; + int size; + int for_size; + int i; + int spacing; + + spacing = get_spacing (self, _gtk_widget_get_style_context (widget)); + + if (self->orientation == GTK_ORIENTATION_HORIZONTAL) + { + size = width; + for_size = height; + } + else + { + size = height; + for_size = width; + baseline = -1; + } + + /* Allocate child sizes */ + + gtk_center_layout_distribute (self, for_size, size, spacing, sizes); + + child[1] = self->center_widget; + child_size[1] = sizes[1].minimum_size; + + if (self->orientation == GTK_ORIENTATION_HORIZONTAL && + gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) + { + child[0] = self->end_widget; + child[2] = self->start_widget; + child_size[0] = sizes[2].minimum_size; + child_size[2] = sizes[0].minimum_size; + } + else + { + child[0] = self->start_widget; + child[2] = self->end_widget; + child_size[0] = sizes[0].minimum_size; + child_size[2] = sizes[2].minimum_size; + } + + /* Determine baseline */ + if (self->orientation == GTK_ORIENTATION_HORIZONTAL && + baseline == -1) + { + int min_above, nat_above; + int min_below, nat_below; + gboolean have_baseline; + + have_baseline = FALSE; + min_above = nat_above = 0; + min_below = nat_below = 0; + + for (i = 0; i < 3; i++) + { + if (child[i] && gtk_widget_get_valign (child[i]) == GTK_ALIGN_BASELINE) + { + int child_min_height, child_nat_height; + int child_min_baseline, child_nat_baseline; + + child_min_baseline = child_nat_baseline = -1; + + gtk_widget_measure (child[i], GTK_ORIENTATION_VERTICAL, + child_size[i], + &child_min_height, &child_nat_height, + &child_min_baseline, &child_nat_baseline); + + if (child_min_baseline >= 0) + { + have_baseline = TRUE; + min_below = MAX (min_below, child_min_height - child_min_baseline); + nat_below = MAX (nat_below, child_nat_height - child_nat_baseline); + min_above = MAX (min_above, child_min_baseline); + nat_above = MAX (nat_above, child_nat_baseline); + } + } + } + + if (have_baseline) + { + /* TODO: This is purely based on the minimum baseline. + * When things fit we should use the natural one + */ + switch (self->baseline_pos) + { + default: + case GTK_BASELINE_POSITION_TOP: + baseline = min_above; + break; + case GTK_BASELINE_POSITION_CENTER: + baseline = min_above + (height - (min_above + min_below)) / 2; + break; + case GTK_BASELINE_POSITION_BOTTOM: + baseline = height - min_below; + break; + } + } + } + + /* Allocate child positions */ + + child_pos[0] = 0; + child_pos[1] = (size / 2) - (child_size[1] / 2); + child_pos[2] = size - child_size[2]; + + if (child[1]) + { + /* Push in from start/end */ + if (child_size[0] > child_pos[1]) + child_pos[1] = child_size[0]; + else if (size - child_size[2] < child_pos[1] + child_size[1]) + child_pos[1] = size - child_size[1] - child_size[2]; + } + + for (i = 0; i < 3; i++) + { + GtkAllocation child_allocation; + + if (child[i] == NULL) + continue; + + if (self->orientation == GTK_ORIENTATION_HORIZONTAL) + { + child_allocation.x = child_pos[i]; + child_allocation.y = 0; + child_allocation.width = child_size[i]; + child_allocation.height = height; + } + else + { + child_allocation.x = 0; + child_allocation.y = child_pos[i]; + child_allocation.width = width; + child_allocation.height = child_size[i]; + } + + gtk_widget_size_allocate (child[i], &child_allocation, baseline); + } +} + +static void +gtk_center_layout_class_init (GtkCenterLayoutClass *klass) +{ + GtkLayoutManagerClass *layout_class = GTK_LAYOUT_MANAGER_CLASS (klass); + + layout_class->get_request_mode = gtk_center_layout_get_request_mode; + layout_class->measure = gtk_center_layout_measure; + layout_class->allocate = gtk_center_layout_allocate; +} + +static void +gtk_center_layout_init (GtkCenterLayout *self) +{ + self->orientation = GTK_ORIENTATION_HORIZONTAL; + self->baseline_pos = GTK_BASELINE_POSITION_CENTER; +} + +/** + * gtk_center_layout_new: + * + * Creates a new #GtkCenterLayout. + * + * Returns: the newly created #GtkCenterLayout + */ +GtkLayoutManager * +gtk_center_layout_new (void) +{ + return g_object_new (GTK_TYPE_CENTER_LAYOUT, NULL); +} + +/** + * gtk_center_layout_set_orientation: + * @self: a #GtkCenterLayout + * @orientation: the new orientation + * + * Sets the orientation of @self. + */ +void +gtk_center_layout_set_orientation (GtkCenterLayout *self, + GtkOrientation orientation) +{ + if (orientation != self->orientation) + { + self->orientation = orientation; + gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (self)); + } +} + +/** + * gtk_center_layout_get_orientation: + * @self: a #GtkCenterLayout + * + * + * Returns: The current orientation of @self + */ +GtkOrientation +gtk_center_layout_get_orientation (GtkCenterLayout *self) +{ + return self->orientation; +} + +/** + * gtk_center_layout_set_baseline_position: + * @self: a #GtkCenterLayout + * @baseline_position: the new baseline position + * + * Sets the new baseline position of @self + */ +void +gtk_center_layout_set_baseline_position (GtkCenterLayout *self, + GtkBaselinePosition baseline_position) +{ + if (baseline_position != self->baseline_pos) + { + self->baseline_pos = baseline_position; + gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (self)); + } +} + +/** + * gtk_center_layout_get_baseline_position: + * @self: a #GtkCenterLayout + * + * Returns: The current baseline position of @self. + */ +GtkBaselinePosition +gtk_center_layout_get_baseline_position (GtkCenterLayout *self) +{ + return self->baseline_pos; +} + +/** + * gtk_center_layout_set_start_widget: + * @self: a #GtkCenterLayout + * @widget: the new start widget + * + * Sets the new start widget of @self. + */ +void +gtk_center_layout_set_start_widget (GtkCenterLayout *self, + GtkWidget *widget) +{ + self->start_widget = widget; +} + +/** + * gtk_center_layout_get_start_widget: + * @self: a #GtkCenterLayout + * + * Returns: (transfer none): The current start widget of @self + */ +GtkWidget * +gtk_center_layout_get_start_widget (GtkCenterLayout *self) +{ + return self->start_widget; +} + +/** + * gtk_center_layout_set_center_widget: + * @self: a #GtkCenterLayout + * @widget: the new center widget + * + * Sets the new center widget of @self + */ +void +gtk_center_layout_set_center_widget (GtkCenterLayout *self, + GtkWidget *widget) +{ + self->center_widget = widget; +} + +/** + * gtk_center_layout_get_center_widget: + * @self: a #GtkCenterLayout + * + * Returns: (transfer none): the current center widget of @self + */ +GtkWidget * +gtk_center_layout_get_center_widget (GtkCenterLayout *self) +{ + return self->center_widget; +} + +/** + * gtk_center_layout_set_end_widget: + * @self: a #GtkCenterLayout + * @widget: (transfer none): the new end widget + * + * Sets the new end widget of @self + */ +void +gtk_center_layout_set_end_widget (GtkCenterLayout *self, + GtkWidget *widget) +{ + self->end_widget = widget; +} + +/** + * gtk_center_layout_get_end_widget: + * @self: a #GtkCenterLayout + * + * Returns: (transfer none): the current end widget of @self + */ +GtkWidget * +gtk_center_layout_get_end_widget (GtkCenterLayout *self) +{ + return self->end_widget; +} diff --git a/gtk/gtkcenterlayout.h b/gtk/gtkcenterlayout.h new file mode 100644 index 0000000000..dde46ec2e5 --- /dev/null +++ b/gtk/gtkcenterlayout.h @@ -0,0 +1,58 @@ +/* + * SPDX-License-Identifier: LGPL-2.1-or-later + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see . + */ + +#pragma once + +#include + +G_BEGIN_DECLS + +#define GTK_TYPE_CENTER_LAYOUT (gtk_center_layout_get_type ()) + +GDK_AVAILABLE_IN_ALL +G_DECLARE_FINAL_TYPE (GtkCenterLayout, gtk_center_layout, GTK, CENTER_LAYOUT, GtkLayoutManager) + +GDK_AVAILABLE_IN_ALL +GtkLayoutManager * gtk_center_layout_new (void); +GDK_AVAILABLE_IN_ALL +void gtk_center_layout_set_orientation (GtkCenterLayout *self, + GtkOrientation orientation); +GDK_AVAILABLE_IN_ALL +GtkOrientation gtk_center_layout_get_orientation (GtkCenterLayout *self); +GDK_AVAILABLE_IN_ALL +void gtk_center_layout_set_baseline_position (GtkCenterLayout *self, + GtkBaselinePosition baseline_position); +GDK_AVAILABLE_IN_ALL +GtkBaselinePosition gtk_center_layout_get_baseline_position (GtkCenterLayout *self); +GDK_AVAILABLE_IN_ALL +void gtk_center_layout_set_start_widget (GtkCenterLayout *self, + GtkWidget *widget); +GDK_AVAILABLE_IN_ALL +GtkWidget * gtk_center_layout_get_start_widget (GtkCenterLayout *self); +GDK_AVAILABLE_IN_ALL +void gtk_center_layout_set_center_widget (GtkCenterLayout *self, + GtkWidget *widget); +GDK_AVAILABLE_IN_ALL +GtkWidget * gtk_center_layout_get_center_widget (GtkCenterLayout *self); +GDK_AVAILABLE_IN_ALL +void gtk_center_layout_set_end_widget (GtkCenterLayout *self, + GtkWidget *widget); +GDK_AVAILABLE_IN_ALL +GtkWidget * gtk_center_layout_get_end_widget (GtkCenterLayout *self); + + +G_END_DECLS diff --git a/gtk/meson.build b/gtk/meson.build index f0474cef00..cf0ed19350 100644 --- a/gtk/meson.build +++ b/gtk/meson.build @@ -194,6 +194,7 @@ gtk_public_sources = files([ 'gtkcellrenderertoggle.c', 'gtkcellview.c', 'gtkcenterbox.c', + 'gtkcenterlayout.c', 'gtkcheckbutton.c', 'gtkcheckmenuitem.c', 'gtkcolorbutton.c', @@ -442,6 +443,7 @@ gtk_public_headers = files([ 'gtkbutton.h', 'gtkcalendar.h', 'gtkcenterbox.h', + 'gtkcenterlayout.h', 'gtkcellarea.h', 'gtkcellareabox.h', 'gtkcellareacontext.h',