2008-07-01 22:57:50 +00:00
|
|
|
|
/* GTK - The GIMP Toolkit
|
1997-11-24 22:37:52 +00:00
|
|
|
|
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
|
|
|
*
|
|
|
|
|
* This library is free software; you can redistribute it and/or
|
2000-07-26 11:33:08 +00:00
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
1997-11-24 22:37:52 +00:00
|
|
|
|
* 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
|
2000-07-26 11:33:08 +00:00
|
|
|
|
* Lesser General Public License for more details.
|
1997-11-24 22:37:52 +00:00
|
|
|
|
*
|
2000-07-26 11:33:08 +00:00
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2012-02-27 13:01:10 +00:00
|
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
1997-11-24 22:37:52 +00:00
|
|
|
|
*/
|
1999-02-24 07:37:18 +00:00
|
|
|
|
|
|
|
|
|
/*
|
2000-07-26 11:33:08 +00:00
|
|
|
|
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
|
1999-02-24 07:37:18 +00:00
|
|
|
|
* file for a list of people on the GTK+ Team. See the ChangeLog
|
|
|
|
|
* files for a list of changes. These files are distributed with
|
2008-10-07 07:44:06 +00:00
|
|
|
|
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
|
1999-02-24 07:37:18 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2010-03-09 22:51:03 +00:00
|
|
|
|
/**
|
|
|
|
|
* SECTION:gtkbox
|
Box, Grid: Improve various bits of documentation
Issue #1495 showed that the docs of GtkGrid retain outdated implications
that (as was once, but is no longer, the case) it is intended to replace
GtkBox, by discussing HfW and widget properties in a way that suggests
GtkBox can't handle them. But of course it does, and it's preferable for
simple single-row/column cases. Worse, we said GtkGrid “provides exactly
the same functionality” for the latter case, but the original point of
that Issues was that it doesn’t, at least for CSS positional selectors!
Box:
• Use an actually meaningful @Short_description.
• Remove unhelpful @See_also references to unrelated containers.
• Remove references to “rectangular area”: it might be another shape
via CSS, or “rectangular” might falsely imply 2 dimensions of children.
• Mention Orientable:orientation.
• Emphasise usefulness of :[hv]align for allocating in the other axis.
• Don’t say that Grid “provides exactly the same functionality” for a
single row or column, since (A) it is overkill for that case and (B)
said Issue proved that it *doesn’t* for CSS child order, for example.
Grid:
• Don’t dwell on widget properties and height-for-width in a way that
wrongly implies that Box can’t handle those (or Grid can better). In
fact, just get rid of that bit altogether: Box handles them fine, and
such wording was only needed years ago for migration from GTK+ 2 to 3.
• Point to GtkBox as being preferred for the simple row/column use case.
2018-12-04 20:37:08 +00:00
|
|
|
|
* @Short_description: A container for packing widgets in a single row or column
|
2010-03-09 22:51:03 +00:00
|
|
|
|
* @Title: GtkBox
|
Box, Grid: Improve various bits of documentation
Issue #1495 showed that the docs of GtkGrid retain outdated implications
that (as was once, but is no longer, the case) it is intended to replace
GtkBox, by discussing HfW and widget properties in a way that suggests
GtkBox can't handle them. But of course it does, and it's preferable for
simple single-row/column cases. Worse, we said GtkGrid “provides exactly
the same functionality” for the latter case, but the original point of
that Issues was that it doesn’t, at least for CSS positional selectors!
Box:
• Use an actually meaningful @Short_description.
• Remove unhelpful @See_also references to unrelated containers.
• Remove references to “rectangular area”: it might be another shape
via CSS, or “rectangular” might falsely imply 2 dimensions of children.
• Mention Orientable:orientation.
• Emphasise usefulness of :[hv]align for allocating in the other axis.
• Don’t say that Grid “provides exactly the same functionality” for a
single row or column, since (A) it is overkill for that case and (B)
said Issue proved that it *doesn’t* for CSS child order, for example.
Grid:
• Don’t dwell on widget properties and height-for-width in a way that
wrongly implies that Box can’t handle those (or Grid can better). In
fact, just get rid of that bit altogether: Box handles them fine, and
such wording was only needed years ago for migration from GTK+ 2 to 3.
• Point to GtkBox as being preferred for the simple row/column use case.
2018-12-04 20:37:08 +00:00
|
|
|
|
* @See_also: #GtkGrid
|
2010-03-09 22:51:03 +00:00
|
|
|
|
*
|
Box, Grid: Improve various bits of documentation
Issue #1495 showed that the docs of GtkGrid retain outdated implications
that (as was once, but is no longer, the case) it is intended to replace
GtkBox, by discussing HfW and widget properties in a way that suggests
GtkBox can't handle them. But of course it does, and it's preferable for
simple single-row/column cases. Worse, we said GtkGrid “provides exactly
the same functionality” for the latter case, but the original point of
that Issues was that it doesn’t, at least for CSS positional selectors!
Box:
• Use an actually meaningful @Short_description.
• Remove unhelpful @See_also references to unrelated containers.
• Remove references to “rectangular area”: it might be another shape
via CSS, or “rectangular” might falsely imply 2 dimensions of children.
• Mention Orientable:orientation.
• Emphasise usefulness of :[hv]align for allocating in the other axis.
• Don’t say that Grid “provides exactly the same functionality” for a
single row or column, since (A) it is overkill for that case and (B)
said Issue proved that it *doesn’t* for CSS child order, for example.
Grid:
• Don’t dwell on widget properties and height-for-width in a way that
wrongly implies that Box can’t handle those (or Grid can better). In
fact, just get rid of that bit altogether: Box handles them fine, and
such wording was only needed years ago for migration from GTK+ 2 to 3.
• Point to GtkBox as being preferred for the simple row/column use case.
2018-12-04 20:37:08 +00:00
|
|
|
|
* The GtkBox widget arranges child widgets into a single row or column,
|
|
|
|
|
* depending upon the value of its #GtkOrientable:orientation property. Within
|
|
|
|
|
* the other dimension, all children are allocated the same size. Of course,
|
|
|
|
|
* the #GtkWidget:halign and #GtkWidget:valign properties can be used on
|
|
|
|
|
* the children to influence their allocation.
|
2010-03-09 22:51:03 +00:00
|
|
|
|
*
|
2014-01-28 06:54:48 +00:00
|
|
|
|
* GtkBox uses a notion of packing. Packing refers
|
2011-06-10 21:40:16 +00:00
|
|
|
|
* to adding widgets with reference to a particular position in a
|
|
|
|
|
* #GtkContainer. For a GtkBox, there are two reference positions: the
|
2014-01-28 06:54:48 +00:00
|
|
|
|
* start and the end of the box.
|
2011-06-10 21:40:16 +00:00
|
|
|
|
* For a vertical #GtkBox, the start is defined as the top of the box and
|
|
|
|
|
* the end is defined as the bottom. For a horizontal #GtkBox the start
|
|
|
|
|
* is defined as the left side and the end is defined as the right side.
|
2010-03-09 22:51:03 +00:00
|
|
|
|
*
|
|
|
|
|
* Use repeated calls to gtk_box_pack_start() to pack widgets into a
|
2011-06-10 21:40:16 +00:00
|
|
|
|
* GtkBox from start to end. Use gtk_box_pack_end() to add widgets from
|
|
|
|
|
* end to start. You may intersperse these calls and add widgets from
|
2010-03-09 22:51:03 +00:00
|
|
|
|
* both ends of the same GtkBox.
|
|
|
|
|
*
|
2011-06-10 21:40:16 +00:00
|
|
|
|
* Because GtkBox is a #GtkContainer, you may also use gtk_container_add()
|
2017-04-21 20:34:36 +00:00
|
|
|
|
* to insert widgets into the box. Use gtk_container_remove()
|
2011-06-10 21:40:16 +00:00
|
|
|
|
* to remove widgets from the GtkBox.
|
2010-03-09 22:51:03 +00:00
|
|
|
|
*
|
|
|
|
|
* Use gtk_box_set_homogeneous() to specify whether or not all children
|
|
|
|
|
* of the GtkBox are forced to get the same amount of space.
|
|
|
|
|
*
|
|
|
|
|
* Use gtk_box_set_spacing() to determine how much space will be
|
2010-10-15 14:58:35 +00:00
|
|
|
|
* minimally placed between all children in the GtkBox. Note that
|
2016-10-02 15:37:22 +00:00
|
|
|
|
* spacing is added between the children.
|
2010-03-09 22:51:03 +00:00
|
|
|
|
*
|
|
|
|
|
* Use gtk_box_reorder_child() to move a GtkBox child to a different
|
|
|
|
|
* place in the box.
|
|
|
|
|
*
|
2015-12-06 06:53:29 +00:00
|
|
|
|
* # CSS nodes
|
2015-11-19 12:07:26 +00:00
|
|
|
|
*
|
2016-01-13 05:39:53 +00:00
|
|
|
|
* GtkBox uses a single CSS node with name box.
|
2010-03-09 22:51:03 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2008-06-22 14:28:52 +00:00
|
|
|
|
#include "config.h"
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
|
#include "gtkbox.h"
|
2011-10-02 20:21:49 +00:00
|
|
|
|
#include "gtkboxprivate.h"
|
2015-02-09 21:51:28 +00:00
|
|
|
|
#include "gtkcssnodeprivate.h"
|
2016-12-10 02:47:53 +00:00
|
|
|
|
#include "gtkcsspositionvalueprivate.h"
|
2012-03-16 19:01:50 +00:00
|
|
|
|
#include "gtkintl.h"
|
2008-10-07 07:44:06 +00:00
|
|
|
|
#include "gtkorientable.h"
|
2012-05-11 15:36:05 +00:00
|
|
|
|
#include "gtkorientableprivate.h"
|
2005-03-22 02:14:55 +00:00
|
|
|
|
#include "gtkprivate.h"
|
2012-03-16 19:01:50 +00:00
|
|
|
|
#include "gtktypebuiltins.h"
|
|
|
|
|
#include "gtksizerequest.h"
|
2016-12-10 02:47:53 +00:00
|
|
|
|
#include "gtkstylecontextprivate.h"
|
2012-03-16 19:01:50 +00:00
|
|
|
|
#include "gtkwidgetpath.h"
|
2012-03-21 08:37:09 +00:00
|
|
|
|
#include "gtkwidgetprivate.h"
|
2012-11-08 01:17:30 +00:00
|
|
|
|
#include "a11y/gtkcontaineraccessible.h"
|
2010-07-09 17:22:23 +00:00
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
1998-01-17 07:52:38 +00:00
|
|
|
|
enum {
|
2001-03-23 23:39:24 +00:00
|
|
|
|
PROP_0,
|
|
|
|
|
PROP_SPACING,
|
2013-03-05 14:20:20 +00:00
|
|
|
|
PROP_HOMOGENEOUS,
|
2014-06-07 14:49:38 +00:00
|
|
|
|
PROP_BASELINE_POSITION,
|
|
|
|
|
|
|
|
|
|
/* orientable */
|
2014-06-07 14:59:14 +00:00
|
|
|
|
PROP_ORIENTATION,
|
|
|
|
|
LAST_PROP = PROP_ORIENTATION
|
1998-01-17 07:52:38 +00:00
|
|
|
|
};
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
1998-06-16 05:20:05 +00:00
|
|
|
|
enum {
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
CHILD_PROP_0,
|
2015-09-07 22:27:02 +00:00
|
|
|
|
CHILD_PROP_POSITION,
|
|
|
|
|
LAST_CHILD_PROP
|
1998-06-16 05:20:05 +00:00
|
|
|
|
};
|
|
|
|
|
|
2014-02-17 03:57:24 +00:00
|
|
|
|
typedef struct _GtkBoxChild GtkBoxChild;
|
|
|
|
|
|
2010-08-26 17:15:37 +00:00
|
|
|
|
struct _GtkBoxPrivate
|
2008-10-07 07:44:06 +00:00
|
|
|
|
{
|
2010-05-24 23:11:54 +00:00
|
|
|
|
GList *children;
|
|
|
|
|
|
2011-04-12 16:24:56 +00:00
|
|
|
|
GtkOrientation orientation;
|
2010-05-24 23:11:54 +00:00
|
|
|
|
gint16 spacing;
|
|
|
|
|
|
|
|
|
|
guint homogeneous : 1;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
guint baseline_pos : 2;
|
2008-10-07 07:44:06 +00:00
|
|
|
|
};
|
2017-10-06 12:24:52 +00:00
|
|
|
|
typedef struct _GtkBoxPrivate GtkBoxPrivate;
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2014-06-07 14:59:14 +00:00
|
|
|
|
static GParamSpec *props[LAST_PROP] = { NULL, };
|
2015-09-07 22:27:02 +00:00
|
|
|
|
static GParamSpec *child_props[LAST_CHILD_PROP] = { NULL, };
|
2014-06-07 14:59:14 +00:00
|
|
|
|
|
2010-07-14 22:54:41 +00:00
|
|
|
|
/*
|
|
|
|
|
* GtkBoxChild:
|
|
|
|
|
* @widget: the child widget, packed into the GtkBox.
|
|
|
|
|
* neighbors, set when packed, zero by default.
|
|
|
|
|
* @pack: one of #GtkPackType indicating whether the child is packed with
|
|
|
|
|
* reference to the start (top/left) or end (bottom/right) of the GtkBox.
|
|
|
|
|
*/
|
|
|
|
|
struct _GtkBoxChild
|
|
|
|
|
{
|
|
|
|
|
GtkWidget *widget;
|
|
|
|
|
|
|
|
|
|
guint pack : 1;
|
|
|
|
|
};
|
2009-12-02 08:48:42 +00:00
|
|
|
|
|
2018-08-16 04:53:03 +00:00
|
|
|
|
static void gtk_box_size_allocate (GtkWidget *widget,
|
|
|
|
|
int width,
|
|
|
|
|
int height,
|
|
|
|
|
int baseline);
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2008-10-07 07:50:04 +00:00
|
|
|
|
static void gtk_box_set_property (GObject *object,
|
|
|
|
|
guint prop_id,
|
|
|
|
|
const GValue *value,
|
|
|
|
|
GParamSpec *pspec);
|
|
|
|
|
static void gtk_box_get_property (GObject *object,
|
|
|
|
|
guint prop_id,
|
|
|
|
|
GValue *value,
|
|
|
|
|
GParamSpec *pspec);
|
|
|
|
|
static void gtk_box_add (GtkContainer *container,
|
|
|
|
|
GtkWidget *widget);
|
|
|
|
|
static void gtk_box_remove (GtkContainer *container,
|
|
|
|
|
GtkWidget *widget);
|
|
|
|
|
static void gtk_box_forall (GtkContainer *container,
|
|
|
|
|
GtkCallback callback,
|
|
|
|
|
gpointer callback_data);
|
|
|
|
|
static void gtk_box_set_child_property (GtkContainer *container,
|
|
|
|
|
GtkWidget *child,
|
|
|
|
|
guint property_id,
|
|
|
|
|
const GValue *value,
|
|
|
|
|
GParamSpec *pspec);
|
|
|
|
|
static void gtk_box_get_child_property (GtkContainer *container,
|
|
|
|
|
GtkWidget *child,
|
|
|
|
|
guint property_id,
|
|
|
|
|
GValue *value,
|
|
|
|
|
GParamSpec *pspec);
|
|
|
|
|
static GType gtk_box_child_type (GtkContainer *container);
|
2011-05-25 21:38:59 +00:00
|
|
|
|
static GtkWidgetPath * gtk_box_get_path_for_child
|
|
|
|
|
(GtkContainer *container,
|
|
|
|
|
GtkWidget *child);
|
2016-10-22 14:06:14 +00:00
|
|
|
|
static void gtk_box_measure (GtkWidget *widget,
|
|
|
|
|
GtkOrientation orientation,
|
|
|
|
|
int for_size,
|
|
|
|
|
int *minimum,
|
|
|
|
|
int *natural,
|
|
|
|
|
int *minimum_baseline,
|
|
|
|
|
int *natural_baseline);
|
2016-08-02 17:44:06 +00:00
|
|
|
|
|
2010-05-25 22:55:15 +00:00
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GtkBox, gtk_box, GTK_TYPE_CONTAINER,
|
2013-06-27 19:02:52 +00:00
|
|
|
|
G_ADD_PRIVATE (GtkBox)
|
2017-04-23 07:30:17 +00:00
|
|
|
|
G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL))
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_box_class_init (GtkBoxClass *class)
|
|
|
|
|
{
|
2008-10-07 07:44:06 +00:00
|
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (class);
|
|
|
|
|
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
GtkContainerClass *container_class = GTK_CONTAINER_CLASS (class);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
2008-10-07 07:44:06 +00:00
|
|
|
|
object_class->set_property = gtk_box_set_property;
|
|
|
|
|
object_class->get_property = gtk_box_get_property;
|
|
|
|
|
|
2016-11-13 23:52:40 +00:00
|
|
|
|
widget_class->size_allocate = gtk_box_size_allocate;
|
|
|
|
|
widget_class->measure = gtk_box_measure;
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
container_class->add = gtk_box_add;
|
|
|
|
|
container_class->remove = gtk_box_remove;
|
|
|
|
|
container_class->forall = gtk_box_forall;
|
|
|
|
|
container_class->child_type = gtk_box_child_type;
|
|
|
|
|
container_class->set_child_property = gtk_box_set_child_property;
|
|
|
|
|
container_class->get_child_property = gtk_box_get_child_property;
|
2011-05-25 21:38:59 +00:00
|
|
|
|
container_class->get_path_for_child = gtk_box_get_path_for_child;
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
|
2008-10-07 07:44:06 +00:00
|
|
|
|
g_object_class_override_property (object_class,
|
|
|
|
|
PROP_ORIENTATION,
|
|
|
|
|
"orientation");
|
|
|
|
|
|
2014-06-07 14:59:14 +00:00
|
|
|
|
props[PROP_SPACING] =
|
|
|
|
|
g_param_spec_int ("spacing",
|
|
|
|
|
P_("Spacing"),
|
|
|
|
|
P_("The amount of space between children"),
|
|
|
|
|
0, G_MAXINT, 0,
|
2014-06-07 15:00:36 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
|
2014-06-07 14:59:14 +00:00
|
|
|
|
|
|
|
|
|
props[PROP_HOMOGENEOUS] =
|
|
|
|
|
g_param_spec_boolean ("homogeneous",
|
|
|
|
|
P_("Homogeneous"),
|
|
|
|
|
P_("Whether the children should all be the same size"),
|
|
|
|
|
FALSE,
|
2014-06-07 15:00:36 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
|
2014-06-07 14:59:14 +00:00
|
|
|
|
|
|
|
|
|
props[PROP_BASELINE_POSITION] =
|
|
|
|
|
g_param_spec_enum ("baseline-position",
|
|
|
|
|
P_("Baseline position"),
|
|
|
|
|
P_("The position of the baseline aligned widgets if extra space is available"),
|
|
|
|
|
GTK_TYPE_BASELINE_POSITION,
|
|
|
|
|
GTK_BASELINE_POSITION_CENTER,
|
2014-06-07 15:00:36 +00:00
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
|
2014-06-07 14:59:14 +00:00
|
|
|
|
|
|
|
|
|
g_object_class_install_properties (object_class, LAST_PROP, props);
|
2013-03-05 14:20:20 +00:00
|
|
|
|
|
2015-09-07 22:27:02 +00:00
|
|
|
|
child_props[CHILD_PROP_POSITION] =
|
|
|
|
|
g_param_spec_int ("position",
|
|
|
|
|
P_("Position"),
|
|
|
|
|
P_("The index of the child in the parent"),
|
|
|
|
|
-1, G_MAXINT,
|
|
|
|
|
0,
|
|
|
|
|
GTK_PARAM_READWRITE);
|
|
|
|
|
|
|
|
|
|
gtk_container_class_install_child_properties (container_class, LAST_CHILD_PROP, child_props);
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2012-11-08 01:17:30 +00:00
|
|
|
|
gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_FILLER);
|
2017-11-18 03:49:57 +00:00
|
|
|
|
gtk_widget_class_set_css_name (widget_class, I_("box"));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-10-07 07:44:06 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_box_set_property (GObject *object,
|
|
|
|
|
guint prop_id,
|
|
|
|
|
const GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
1998-01-17 07:52:38 +00:00
|
|
|
|
{
|
2008-10-07 07:44:06 +00:00
|
|
|
|
GtkBox *box = GTK_BOX (object);
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
1998-06-28 07:46:10 +00:00
|
|
|
|
|
2001-03-23 23:39:24 +00:00
|
|
|
|
switch (prop_id)
|
1998-01-17 07:52:38 +00:00
|
|
|
|
{
|
2008-10-07 07:44:06 +00:00
|
|
|
|
case PROP_ORIENTATION:
|
2014-06-07 14:59:14 +00:00
|
|
|
|
{
|
|
|
|
|
GtkOrientation orientation = g_value_get_enum (value);
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->orientation != orientation)
|
2014-06-07 14:59:14 +00:00
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
priv->orientation = orientation;
|
2014-06-07 14:59:14 +00:00
|
|
|
|
_gtk_orientable_set_style_classes (GTK_ORIENTABLE (box));
|
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (box));
|
|
|
|
|
g_object_notify (object, "orientation");
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-10-07 07:44:06 +00:00
|
|
|
|
break;
|
2001-03-23 23:39:24 +00:00
|
|
|
|
case PROP_SPACING:
|
|
|
|
|
gtk_box_set_spacing (box, g_value_get_int (value));
|
1998-01-17 07:52:38 +00:00
|
|
|
|
break;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
case PROP_BASELINE_POSITION:
|
|
|
|
|
gtk_box_set_baseline_position (box, g_value_get_enum (value));
|
|
|
|
|
break;
|
2001-03-23 23:39:24 +00:00
|
|
|
|
case PROP_HOMOGENEOUS:
|
|
|
|
|
gtk_box_set_homogeneous (box, g_value_get_boolean (value));
|
1998-01-17 07:52:38 +00:00
|
|
|
|
break;
|
1998-01-21 23:03:11 +00:00
|
|
|
|
default:
|
2001-03-23 23:39:24 +00:00
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
1998-01-21 23:03:11 +00:00
|
|
|
|
break;
|
1998-01-17 07:52:38 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-07 07:44:06 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_box_get_property (GObject *object,
|
|
|
|
|
guint prop_id,
|
|
|
|
|
GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
1998-01-17 07:52:38 +00:00
|
|
|
|
{
|
2008-10-07 07:44:06 +00:00
|
|
|
|
GtkBox *box = GTK_BOX (object);
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
1998-06-28 07:46:10 +00:00
|
|
|
|
|
2001-03-23 23:39:24 +00:00
|
|
|
|
switch (prop_id)
|
1998-01-17 07:52:38 +00:00
|
|
|
|
{
|
2008-10-07 07:44:06 +00:00
|
|
|
|
case PROP_ORIENTATION:
|
2018-02-07 19:03:25 +00:00
|
|
|
|
g_value_set_enum (value, priv->orientation);
|
2008-10-07 07:44:06 +00:00
|
|
|
|
break;
|
2001-03-23 23:39:24 +00:00
|
|
|
|
case PROP_SPACING:
|
2018-02-07 19:03:25 +00:00
|
|
|
|
g_value_set_int (value, priv->spacing);
|
1998-01-17 07:52:38 +00:00
|
|
|
|
break;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
case PROP_BASELINE_POSITION:
|
2018-02-07 19:03:25 +00:00
|
|
|
|
g_value_set_enum (value, priv->baseline_pos);
|
2013-03-05 14:20:20 +00:00
|
|
|
|
break;
|
2001-03-23 23:39:24 +00:00
|
|
|
|
case PROP_HOMOGENEOUS:
|
2018-02-07 19:03:25 +00:00
|
|
|
|
g_value_set_boolean (value, priv->homogeneous);
|
1998-01-17 07:52:38 +00:00
|
|
|
|
break;
|
|
|
|
|
default:
|
2001-03-23 23:39:24 +00:00
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
1998-01-17 07:52:38 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-07 07:44:06 +00:00
|
|
|
|
static void
|
2010-05-24 23:11:54 +00:00
|
|
|
|
count_expand_children (GtkBox *box,
|
|
|
|
|
gint *visible_children,
|
|
|
|
|
gint *expand_children)
|
2008-10-07 07:44:06 +00:00
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2017-05-23 13:05:32 +00:00
|
|
|
|
GtkWidget *child;
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2010-04-18 22:09:40 +00:00
|
|
|
|
*visible_children = *expand_children = 0;
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2017-05-23 13:05:32 +00:00
|
|
|
|
for (child = _gtk_widget_get_first_child (GTK_WIDGET (box));
|
|
|
|
|
child != NULL;
|
|
|
|
|
child = _gtk_widget_get_next_sibling (child))
|
2008-10-07 07:44:06 +00:00
|
|
|
|
{
|
2017-05-23 13:05:32 +00:00
|
|
|
|
if (_gtk_widget_get_visible (child))
|
|
|
|
|
{
|
|
|
|
|
*visible_children += 1;
|
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (gtk_widget_compute_expand (child, priv->orientation))
|
2017-05-23 13:05:32 +00:00
|
|
|
|
*expand_children += 1;
|
|
|
|
|
}
|
2008-10-07 07:44:06 +00:00
|
|
|
|
}
|
2010-04-18 22:09:40 +00:00
|
|
|
|
}
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2016-12-10 02:47:53 +00:00
|
|
|
|
static gint
|
|
|
|
|
get_spacing (GtkBox *box)
|
|
|
|
|
{
|
2017-10-06 12:24:52 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2016-12-10 02:47:53 +00:00
|
|
|
|
GtkCssValue *border_spacing;
|
|
|
|
|
gint css_spacing;
|
|
|
|
|
|
|
|
|
|
border_spacing = _gtk_style_context_peek_property (gtk_widget_get_style_context (GTK_WIDGET (box)), GTK_CSS_PROPERTY_BORDER_SPACING);
|
|
|
|
|
if (priv->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 + priv->spacing;
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-07 07:44:06 +00:00
|
|
|
|
static void
|
2018-08-16 04:53:03 +00:00
|
|
|
|
gtk_box_size_allocate (GtkWidget *widget,
|
|
|
|
|
int width,
|
|
|
|
|
int height,
|
|
|
|
|
int baseline)
|
2008-10-07 07:44:06 +00:00
|
|
|
|
{
|
|
|
|
|
GtkBox *box = GTK_BOX (widget);
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2008-10-07 07:44:06 +00:00
|
|
|
|
GtkBoxChild *child;
|
|
|
|
|
GList *children;
|
2009-12-02 08:48:42 +00:00
|
|
|
|
gint nvis_children;
|
|
|
|
|
gint nexpand_children;
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2010-08-06 20:07:42 +00:00
|
|
|
|
GtkTextDirection direction;
|
|
|
|
|
GtkAllocation child_allocation;
|
|
|
|
|
GtkRequestedSize *sizes;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
gint child_minimum_baseline, child_natural_baseline;
|
|
|
|
|
gint minimum_above, natural_above;
|
|
|
|
|
gint minimum_below, natural_below;
|
|
|
|
|
gboolean have_baseline;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
|
|
|
|
GtkPackType packing;
|
|
|
|
|
|
2016-12-25 23:16:14 +00:00
|
|
|
|
gint extra_space;
|
|
|
|
|
gint children_minimum_size = 0;
|
|
|
|
|
gint size_given_to_child;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
gint n_extra_widgets = 0; /* Number of widgets that receive 1 extra px */
|
|
|
|
|
gint x = 0, y = 0, i;
|
|
|
|
|
gint child_size;
|
2016-12-10 02:47:53 +00:00
|
|
|
|
gint spacing;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
|
|
|
|
|
2010-04-18 22:09:40 +00:00
|
|
|
|
count_expand_children (box, &nvis_children, &nexpand_children);
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2010-08-06 20:07:42 +00:00
|
|
|
|
/* If there is no visible child, simply return. */
|
|
|
|
|
if (nvis_children <= 0)
|
|
|
|
|
return;
|
|
|
|
|
|
2017-01-11 14:27:51 +00:00
|
|
|
|
direction = _gtk_widget_get_direction (widget);
|
2010-08-06 20:07:42 +00:00
|
|
|
|
sizes = g_newa (GtkRequestedSize, nvis_children);
|
2016-12-10 02:47:53 +00:00
|
|
|
|
spacing = get_spacing (box);
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
|
2018-08-16 04:53:03 +00:00
|
|
|
|
extra_space = width - (nvis_children - 1) * spacing;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
else
|
2018-08-16 04:53:03 +00:00
|
|
|
|
extra_space = height - (nvis_children - 1) * spacing;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
2013-03-05 14:20:20 +00:00
|
|
|
|
have_baseline = FALSE;
|
|
|
|
|
minimum_above = natural_above = 0;
|
|
|
|
|
minimum_below = natural_below = 0;
|
|
|
|
|
|
2010-08-06 20:07:42 +00:00
|
|
|
|
/* Retrieve desired size for visible children. */
|
2018-02-07 19:03:25 +00:00
|
|
|
|
for (i = 0, children = priv->children; children; children = children->next)
|
2008-10-07 07:44:06 +00:00
|
|
|
|
{
|
2010-08-06 20:07:42 +00:00
|
|
|
|
child = children->data;
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2015-09-06 23:58:03 +00:00
|
|
|
|
if (!_gtk_widget_get_visible (child->widget))
|
2010-08-06 20:07:42 +00:00
|
|
|
|
continue;
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2016-10-29 14:35:16 +00:00
|
|
|
|
gtk_widget_measure (child->widget,
|
2018-02-07 19:03:25 +00:00
|
|
|
|
priv->orientation,
|
2018-08-16 04:53:03 +00:00
|
|
|
|
priv->orientation == GTK_ORIENTATION_HORIZONTAL ? height : width,
|
2016-10-29 14:35:16 +00:00
|
|
|
|
&sizes[i].minimum_size, &sizes[i].natural_size,
|
|
|
|
|
NULL, NULL);
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
2016-12-25 23:16:14 +00:00
|
|
|
|
children_minimum_size += sizes[i].minimum_size;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
|
|
|
|
sizes[i].data = child;
|
|
|
|
|
|
|
|
|
|
i++;
|
|
|
|
|
}
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->homogeneous)
|
2010-08-06 20:07:42 +00:00
|
|
|
|
{
|
2016-12-25 23:16:14 +00:00
|
|
|
|
/* We still need to run the above loop to populate the minimum sizes for
|
|
|
|
|
* children that aren't going to fill.
|
2010-08-06 20:07:42 +00:00
|
|
|
|
*/
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2016-12-25 23:16:14 +00:00
|
|
|
|
size_given_to_child = extra_space / nvis_children;
|
|
|
|
|
n_extra_widgets = extra_space % nvis_children;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2016-12-26 10:57:51 +00:00
|
|
|
|
/* Bring children up to size first */
|
2016-12-25 23:16:14 +00:00
|
|
|
|
extra_space -= children_minimum_size;
|
|
|
|
|
extra_space = MAX (0, extra_space);
|
|
|
|
|
extra_space = gtk_distribute_natural_allocation (extra_space, nvis_children, sizes);
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2010-08-06 20:07:42 +00:00
|
|
|
|
/* Calculate space which hasn't distributed yet,
|
|
|
|
|
* and is available for expanding children.
|
|
|
|
|
*/
|
|
|
|
|
if (nexpand_children > 0)
|
|
|
|
|
{
|
2016-12-25 23:16:14 +00:00
|
|
|
|
size_given_to_child = extra_space / nexpand_children;
|
|
|
|
|
n_extra_widgets = extra_space % nexpand_children;
|
2008-10-07 07:44:06 +00:00
|
|
|
|
}
|
2010-08-06 20:07:42 +00:00
|
|
|
|
else
|
2016-12-25 23:16:14 +00:00
|
|
|
|
{
|
|
|
|
|
size_given_to_child = 0;
|
|
|
|
|
}
|
2010-08-06 20:07:42 +00:00
|
|
|
|
}
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2013-03-05 14:20:20 +00:00
|
|
|
|
/* Allocate child sizes. */
|
2010-08-06 20:07:42 +00:00
|
|
|
|
for (packing = GTK_PACK_START; packing <= GTK_PACK_END; ++packing)
|
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
for (i = 0, children = priv->children;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
children;
|
|
|
|
|
children = children->next)
|
|
|
|
|
{
|
|
|
|
|
child = children->data;
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2010-08-06 23:58:29 +00:00
|
|
|
|
/* If widget is not visible, skip it. */
|
2015-09-06 23:58:03 +00:00
|
|
|
|
if (!_gtk_widget_get_visible (child->widget))
|
2010-08-06 20:07:42 +00:00
|
|
|
|
continue;
|
2008-10-07 07:44:06 +00:00
|
|
|
|
|
2010-08-06 23:58:29 +00:00
|
|
|
|
/* If widget is packed differently skip it, but still increment i,
|
|
|
|
|
* since widget is visible and will be handled in next loop iteration.
|
|
|
|
|
*/
|
|
|
|
|
if (child->pack != packing)
|
|
|
|
|
{
|
|
|
|
|
i++;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-06 20:07:42 +00:00
|
|
|
|
/* Assign the child's size. */
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->homogeneous)
|
2008-10-07 07:44:06 +00:00
|
|
|
|
{
|
2016-12-25 23:16:14 +00:00
|
|
|
|
child_size = size_given_to_child;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
|
|
|
|
if (n_extra_widgets > 0)
|
|
|
|
|
{
|
|
|
|
|
child_size++;
|
|
|
|
|
n_extra_widgets--;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2016-10-02 15:37:22 +00:00
|
|
|
|
child_size = sizes[i].minimum_size;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (gtk_widget_compute_expand (child->widget, priv->orientation))
|
2010-08-06 20:07:42 +00:00
|
|
|
|
{
|
2016-12-25 23:16:14 +00:00
|
|
|
|
child_size += size_given_to_child;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
|
|
|
|
if (n_extra_widgets > 0)
|
|
|
|
|
{
|
|
|
|
|
child_size++;
|
|
|
|
|
n_extra_widgets--;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-05 14:20:20 +00:00
|
|
|
|
sizes[i].natural_size = child_size;
|
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL &&
|
2017-07-05 09:09:27 +00:00
|
|
|
|
gtk_widget_get_valign (child->widget) == GTK_ALIGN_BASELINE)
|
2013-03-05 14:20:20 +00:00
|
|
|
|
{
|
|
|
|
|
int child_allocation_width;
|
|
|
|
|
int child_minimum_height, child_natural_height;
|
|
|
|
|
|
2017-10-06 09:16:35 +00:00
|
|
|
|
child_allocation_width = child_size;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
|
|
|
|
|
child_minimum_baseline = -1;
|
|
|
|
|
child_natural_baseline = -1;
|
2016-10-29 14:35:16 +00:00
|
|
|
|
gtk_widget_measure (child->widget, GTK_ORIENTATION_VERTICAL,
|
|
|
|
|
child_allocation_width,
|
|
|
|
|
&child_minimum_height, &child_natural_height,
|
|
|
|
|
&child_minimum_baseline, &child_natural_baseline);
|
2013-03-05 14:20:20 +00:00
|
|
|
|
|
|
|
|
|
if (child_minimum_baseline >= 0)
|
|
|
|
|
{
|
|
|
|
|
have_baseline = TRUE;
|
|
|
|
|
minimum_below = MAX (minimum_below, child_minimum_height - child_minimum_baseline);
|
|
|
|
|
natural_below = MAX (natural_below, child_natural_height - child_natural_baseline);
|
|
|
|
|
minimum_above = MAX (minimum_above, child_minimum_baseline);
|
|
|
|
|
natural_above = MAX (natural_above, child_natural_baseline);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
i++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
|
2017-07-11 07:58:21 +00:00
|
|
|
|
baseline = -1;
|
2017-07-05 09:09:27 +00:00
|
|
|
|
|
|
|
|
|
/* we only calculate our own baseline if we don't get one passed from the parent
|
|
|
|
|
* and any of the child widgets explicitly request one */
|
2013-03-05 14:20:20 +00:00
|
|
|
|
if (baseline == -1 && have_baseline)
|
|
|
|
|
{
|
|
|
|
|
/* TODO: This is purely based on the minimum baseline, when things fit we should
|
|
|
|
|
use the natural one? */
|
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
switch (priv->baseline_pos)
|
2013-03-05 14:20:20 +00:00
|
|
|
|
{
|
|
|
|
|
case GTK_BASELINE_POSITION_TOP:
|
|
|
|
|
baseline = minimum_above;
|
|
|
|
|
break;
|
|
|
|
|
case GTK_BASELINE_POSITION_CENTER:
|
|
|
|
|
baseline = minimum_above + (height - (minimum_above + minimum_below)) / 2;
|
|
|
|
|
break;
|
|
|
|
|
case GTK_BASELINE_POSITION_BOTTOM:
|
|
|
|
|
baseline = height - minimum_below;
|
|
|
|
|
break;
|
2017-10-06 19:19:42 +00:00
|
|
|
|
default:
|
|
|
|
|
break;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Allocate child positions. */
|
|
|
|
|
for (packing = GTK_PACK_START; packing <= GTK_PACK_END; ++packing)
|
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
|
2013-03-05 14:20:20 +00:00
|
|
|
|
{
|
2018-02-06 22:58:06 +00:00
|
|
|
|
child_allocation.y = 0;
|
2018-08-16 04:53:03 +00:00
|
|
|
|
child_allocation.height = height;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
if (packing == GTK_PACK_START)
|
2018-02-06 22:58:06 +00:00
|
|
|
|
x = 0;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
else
|
2018-08-16 04:53:03 +00:00
|
|
|
|
x = width;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2018-02-06 22:58:06 +00:00
|
|
|
|
child_allocation.x = 0;
|
2018-08-16 04:53:03 +00:00
|
|
|
|
child_allocation.width = width;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
if (packing == GTK_PACK_START)
|
2018-02-06 22:58:06 +00:00
|
|
|
|
y = 0;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
else
|
2018-08-16 04:53:03 +00:00
|
|
|
|
y = height;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
for (i = 0, children = priv->children;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
children;
|
|
|
|
|
children = children->next)
|
|
|
|
|
{
|
|
|
|
|
child = children->data;
|
|
|
|
|
|
|
|
|
|
/* If widget is not visible, skip it. */
|
2015-09-06 23:58:03 +00:00
|
|
|
|
if (!_gtk_widget_get_visible (child->widget))
|
2013-03-05 14:20:20 +00:00
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* If widget is packed differently skip it, but still increment i,
|
|
|
|
|
* since widget is visible and will be handled in next loop iteration.
|
|
|
|
|
*/
|
|
|
|
|
if (child->pack != packing)
|
|
|
|
|
{
|
|
|
|
|
i++;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
child_size = sizes[i].natural_size;
|
|
|
|
|
|
2010-08-06 20:07:42 +00:00
|
|
|
|
/* Assign the child's position. */
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
|
2010-08-06 20:07:42 +00:00
|
|
|
|
{
|
2017-10-06 09:16:35 +00:00
|
|
|
|
child_allocation.width = child_size;
|
2017-04-21 20:34:36 +00:00
|
|
|
|
child_allocation.x = x;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
|
|
|
|
if (packing == GTK_PACK_START)
|
|
|
|
|
{
|
2016-12-10 02:47:53 +00:00
|
|
|
|
x += child_size + spacing;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2016-12-10 02:47:53 +00:00
|
|
|
|
x -= child_size + spacing;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
|
|
|
|
child_allocation.x -= child_size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (direction == GTK_TEXT_DIR_RTL)
|
2018-08-16 04:53:03 +00:00
|
|
|
|
child_allocation.x = width - child_allocation.x - child_allocation.width;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
2008-10-07 07:44:06 +00:00
|
|
|
|
}
|
2018-02-07 19:03:25 +00:00
|
|
|
|
else /* (priv->orientation == GTK_ORIENTATION_VERTICAL) */
|
2010-08-06 20:07:42 +00:00
|
|
|
|
{
|
2017-10-06 09:16:35 +00:00
|
|
|
|
child_allocation.height = child_size;
|
2017-04-21 20:34:36 +00:00
|
|
|
|
child_allocation.y = y;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
|
|
|
|
if (packing == GTK_PACK_START)
|
|
|
|
|
{
|
2016-12-10 02:47:53 +00:00
|
|
|
|
y += child_size + spacing;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2016-12-10 02:47:53 +00:00
|
|
|
|
y -= child_size + spacing;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
|
|
|
|
child_allocation.y -= child_size;
|
|
|
|
|
}
|
|
|
|
|
}
|
2018-03-31 19:02:28 +00:00
|
|
|
|
gtk_widget_size_allocate (child->widget, &child_allocation, baseline);
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
|
|
|
|
i++;
|
2008-10-07 07:44:06 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-10-07 04:29:52 +00:00
|
|
|
|
static GType
|
|
|
|
|
gtk_box_child_type (GtkContainer *container)
|
1998-06-16 05:20:05 +00:00
|
|
|
|
{
|
|
|
|
|
return GTK_TYPE_WIDGET;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2008-10-07 07:50:04 +00:00
|
|
|
|
gtk_box_set_child_property (GtkContainer *container,
|
|
|
|
|
GtkWidget *child,
|
|
|
|
|
guint property_id,
|
|
|
|
|
const GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
1998-06-16 05:20:05 +00:00
|
|
|
|
{
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
switch (property_id)
|
1998-06-16 05:20:05 +00:00
|
|
|
|
{
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
case CHILD_PROP_POSITION:
|
1998-06-16 05:20:05 +00:00
|
|
|
|
gtk_box_reorder_child (GTK_BOX (container),
|
|
|
|
|
child,
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
g_value_get_int (value));
|
1998-06-16 05:20:05 +00:00
|
|
|
|
break;
|
|
|
|
|
default:
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
|
1998-06-16 05:20:05 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
gtk_box_get_child_property (GtkContainer *container,
|
|
|
|
|
GtkWidget *child,
|
|
|
|
|
guint property_id,
|
|
|
|
|
GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
1998-06-16 05:20:05 +00:00
|
|
|
|
{
|
2017-10-06 12:24:52 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (GTK_BOX (container));
|
1998-06-16 05:20:05 +00:00
|
|
|
|
GList *list;
|
2018-12-26 08:49:10 +00:00
|
|
|
|
int i;
|
1998-06-16 05:20:05 +00:00
|
|
|
|
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
switch (property_id)
|
1998-06-16 05:20:05 +00:00
|
|
|
|
{
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
case CHILD_PROP_POSITION:
|
|
|
|
|
i = 0;
|
2017-10-06 12:24:52 +00:00
|
|
|
|
for (list = priv->children; list; list = list->next)
|
1998-06-16 05:20:05 +00:00
|
|
|
|
{
|
|
|
|
|
GtkBoxChild *child_entry;
|
|
|
|
|
|
|
|
|
|
child_entry = list->data;
|
|
|
|
|
if (child_entry->widget == child)
|
|
|
|
|
break;
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
i++;
|
1998-06-16 05:20:05 +00:00
|
|
|
|
}
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
g_value_set_int (value, list ? i : -1);
|
1998-06-16 05:20:05 +00:00
|
|
|
|
break;
|
|
|
|
|
default:
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
|
1998-06-16 05:20:05 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:38:59 +00:00
|
|
|
|
typedef struct _CountingData CountingData;
|
|
|
|
|
struct _CountingData {
|
|
|
|
|
GtkWidget *widget;
|
|
|
|
|
gboolean found;
|
2011-05-27 22:17:01 +00:00
|
|
|
|
guint before;
|
|
|
|
|
guint after;
|
2011-05-25 21:38:59 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
count_widget_position (GtkWidget *widget,
|
|
|
|
|
gpointer data)
|
|
|
|
|
{
|
|
|
|
|
CountingData *count = data;
|
|
|
|
|
|
2015-09-06 23:58:03 +00:00
|
|
|
|
if (!_gtk_widget_get_visible (widget))
|
2011-05-25 21:38:59 +00:00
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (count->widget == widget)
|
2011-05-27 22:17:01 +00:00
|
|
|
|
count->found = TRUE;
|
2013-02-22 14:14:19 +00:00
|
|
|
|
else if (count->found)
|
|
|
|
|
count->after++;
|
|
|
|
|
else
|
2011-05-27 22:17:01 +00:00
|
|
|
|
count->before++;
|
2011-05-25 21:38:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-09-25 22:46:16 +00:00
|
|
|
|
static gint
|
|
|
|
|
gtk_box_get_visible_position (GtkBox *box,
|
2011-05-25 21:38:59 +00:00
|
|
|
|
GtkWidget *child)
|
|
|
|
|
{
|
2011-05-27 22:17:01 +00:00
|
|
|
|
CountingData count = { child, FALSE, 0, 0 };
|
2017-10-06 12:24:52 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2011-05-25 21:38:59 +00:00
|
|
|
|
|
2011-09-25 22:46:16 +00:00
|
|
|
|
/* foreach iterates in visible order */
|
|
|
|
|
gtk_container_foreach (GTK_CONTAINER (box),
|
|
|
|
|
count_widget_position,
|
|
|
|
|
&count);
|
|
|
|
|
|
|
|
|
|
/* the child wasn't found, it's likely an internal child of some
|
|
|
|
|
* subclass, return -1 to indicate that there is no sibling relation
|
|
|
|
|
* to the regular box children
|
|
|
|
|
*/
|
|
|
|
|
if (!count.found)
|
|
|
|
|
return -1;
|
2011-05-25 21:38:59 +00:00
|
|
|
|
|
2017-10-06 12:24:52 +00:00
|
|
|
|
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL &&
|
2013-02-22 14:14:19 +00:00
|
|
|
|
gtk_widget_get_direction (GTK_WIDGET (box)) == GTK_TEXT_DIR_RTL)
|
|
|
|
|
return count.after;
|
|
|
|
|
else
|
|
|
|
|
return count.before;
|
2011-05-25 21:38:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static GtkWidgetPath *
|
|
|
|
|
gtk_box_get_path_for_child (GtkContainer *container,
|
|
|
|
|
GtkWidget *child)
|
|
|
|
|
{
|
2011-07-01 23:25:45 +00:00
|
|
|
|
GtkWidgetPath *path, *sibling_path;
|
2017-10-06 12:24:52 +00:00
|
|
|
|
GtkBox *box = GTK_BOX (container);
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2011-07-01 23:25:45 +00:00
|
|
|
|
GList *list, *children;
|
2011-05-25 21:38:59 +00:00
|
|
|
|
|
2012-04-07 12:15:35 +00:00
|
|
|
|
path = _gtk_widget_create_path (GTK_WIDGET (container));
|
2011-07-01 23:25:45 +00:00
|
|
|
|
|
2015-09-06 23:58:03 +00:00
|
|
|
|
if (_gtk_widget_get_visible (child))
|
2011-05-25 21:38:59 +00:00
|
|
|
|
{
|
2011-09-25 22:46:16 +00:00
|
|
|
|
gint position;
|
|
|
|
|
|
2011-07-01 23:25:45 +00:00
|
|
|
|
sibling_path = gtk_widget_path_new ();
|
2011-05-27 22:17:01 +00:00
|
|
|
|
|
|
|
|
|
/* get_children works in visible order */
|
|
|
|
|
children = gtk_container_get_children (container);
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL &&
|
2017-01-11 14:27:51 +00:00
|
|
|
|
_gtk_widget_get_direction (GTK_WIDGET (box)) == GTK_TEXT_DIR_RTL)
|
2013-02-22 14:14:19 +00:00
|
|
|
|
children = g_list_reverse (children);
|
2011-05-27 22:17:01 +00:00
|
|
|
|
|
|
|
|
|
for (list = children; list; list = list->next)
|
|
|
|
|
{
|
2015-09-06 23:58:03 +00:00
|
|
|
|
if (!_gtk_widget_get_visible (list->data))
|
2011-06-30 20:19:57 +00:00
|
|
|
|
continue;
|
|
|
|
|
|
2011-07-01 23:25:45 +00:00
|
|
|
|
gtk_widget_path_append_for_widget (sibling_path, list->data);
|
2011-05-27 22:17:01 +00:00
|
|
|
|
}
|
2011-05-25 21:38:59 +00:00
|
|
|
|
|
2011-09-25 22:46:16 +00:00
|
|
|
|
g_list_free (children);
|
|
|
|
|
|
|
|
|
|
position = gtk_box_get_visible_position (box, child);
|
|
|
|
|
|
|
|
|
|
if (position >= 0)
|
|
|
|
|
gtk_widget_path_append_with_siblings (path, sibling_path, position);
|
|
|
|
|
else
|
|
|
|
|
gtk_widget_path_append_for_widget (path, child);
|
|
|
|
|
|
|
|
|
|
gtk_widget_path_unref (sibling_path);
|
2011-07-01 23:25:45 +00:00
|
|
|
|
}
|
2011-05-25 21:38:59 +00:00
|
|
|
|
else
|
|
|
|
|
gtk_widget_path_append_for_widget (path, child);
|
|
|
|
|
|
|
|
|
|
return path;
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-12 16:27:19 +00:00
|
|
|
|
static void
|
2015-11-09 00:29:56 +00:00
|
|
|
|
gtk_box_update_child_css_position (GtkBox *box,
|
|
|
|
|
GtkBoxChild *child_info)
|
2015-05-12 16:27:19 +00:00
|
|
|
|
{
|
2017-10-06 12:24:52 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2015-11-09 00:29:56 +00:00
|
|
|
|
GtkBoxChild *prev;
|
|
|
|
|
gboolean reverse;
|
|
|
|
|
GList *l;
|
2015-05-12 16:27:19 +00:00
|
|
|
|
|
2015-11-09 00:29:56 +00:00
|
|
|
|
prev = NULL;
|
|
|
|
|
for (l = priv->children; l->data != child_info; l = l->next)
|
|
|
|
|
{
|
|
|
|
|
GtkBoxChild *cur = l->data;
|
2015-05-12 16:27:19 +00:00
|
|
|
|
|
2015-11-09 00:29:56 +00:00
|
|
|
|
if (cur->pack == child_info->pack)
|
|
|
|
|
prev = cur;
|
|
|
|
|
}
|
2015-07-12 19:39:49 +00:00
|
|
|
|
|
2015-11-09 00:29:56 +00:00
|
|
|
|
reverse = child_info->pack == GTK_PACK_END;
|
2015-05-12 16:27:19 +00:00
|
|
|
|
|
2015-11-09 00:29:56 +00:00
|
|
|
|
if (reverse)
|
|
|
|
|
gtk_css_node_insert_before (gtk_widget_get_css_node (GTK_WIDGET (box)),
|
|
|
|
|
gtk_widget_get_css_node (child_info->widget),
|
|
|
|
|
prev ? gtk_widget_get_css_node (prev->widget) : NULL);
|
|
|
|
|
else
|
|
|
|
|
gtk_css_node_insert_after (gtk_widget_get_css_node (GTK_WIDGET (box)),
|
|
|
|
|
gtk_widget_get_css_node (child_info->widget),
|
|
|
|
|
prev ? gtk_widget_get_css_node (prev->widget) : NULL);
|
2011-05-25 21:38:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-09-29 08:50:33 +00:00
|
|
|
|
static void
|
2008-06-28 16:16:26 +00:00
|
|
|
|
gtk_box_pack (GtkBox *box,
|
2018-12-26 08:49:10 +00:00
|
|
|
|
GtkWidget *child)
|
2008-06-28 16:16:26 +00:00
|
|
|
|
{
|
2015-09-07 22:27:02 +00:00
|
|
|
|
GtkContainer *container = GTK_CONTAINER (box);
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2008-06-28 16:16:26 +00:00
|
|
|
|
GtkBoxChild *child_info;
|
|
|
|
|
|
2017-09-29 08:50:33 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_BOX (box));
|
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
|
|
|
|
g_return_if_fail (_gtk_widget_get_parent (child) == NULL);
|
2008-06-28 16:16:26 +00:00
|
|
|
|
|
|
|
|
|
child_info = g_new (GtkBoxChild, 1);
|
|
|
|
|
child_info->widget = child;
|
2018-12-26 08:49:10 +00:00
|
|
|
|
child_info->pack = GTK_PACK_START;
|
2008-06-28 16:16:26 +00:00
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
priv->children = g_list_append (priv->children, child_info);
|
2015-11-09 00:29:56 +00:00
|
|
|
|
gtk_box_update_child_css_position (box, child_info);
|
2008-06-28 16:16:26 +00:00
|
|
|
|
|
|
|
|
|
gtk_widget_freeze_child_notify (child);
|
|
|
|
|
|
|
|
|
|
gtk_widget_set_parent (child, GTK_WIDGET (box));
|
2010-11-02 09:43:42 +00:00
|
|
|
|
|
2015-09-07 22:27:02 +00:00
|
|
|
|
gtk_container_child_notify_by_pspec (container, child, child_props[CHILD_PROP_POSITION]);
|
|
|
|
|
|
2008-06-28 16:16:26 +00:00
|
|
|
|
gtk_widget_thaw_child_notify (child);
|
|
|
|
|
}
|
|
|
|
|
|
2010-11-02 09:43:42 +00:00
|
|
|
|
static void
|
2010-04-18 22:09:40 +00:00
|
|
|
|
gtk_box_compute_size_for_opposing_orientation (GtkBox *box,
|
2018-08-27 16:48:09 +00:00
|
|
|
|
int for_size,
|
2010-04-18 22:09:40 +00:00
|
|
|
|
gint *minimum_size,
|
2013-03-05 14:20:20 +00:00
|
|
|
|
gint *natural_size,
|
|
|
|
|
gint *minimum_baseline,
|
|
|
|
|
gint *natural_baseline)
|
2010-04-10 01:50:33 +00:00
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2018-02-06 21:19:30 +00:00
|
|
|
|
GtkWidget *widget = GTK_WIDGET (box);
|
|
|
|
|
GtkWidget *child;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
gint nvis_children;
|
|
|
|
|
gint nexpand_children;
|
|
|
|
|
gint computed_minimum = 0, computed_natural = 0;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
gint computed_minimum_above = 0, computed_natural_above = 0;
|
|
|
|
|
gint computed_minimum_below = 0, computed_natural_below = 0;
|
|
|
|
|
gint computed_minimum_baseline = -1, computed_natural_baseline = -1;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
GtkRequestedSize *sizes;
|
2016-12-25 23:16:14 +00:00
|
|
|
|
gint extra_space, size_given_to_child, i;
|
|
|
|
|
gint children_minimum_size = 0;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
gint child_size, child_minimum, child_natural;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
gint child_minimum_baseline, child_natural_baseline;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
gint n_extra_widgets = 0;
|
2016-12-10 02:47:53 +00:00
|
|
|
|
gint spacing;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
gboolean have_baseline;
|
2010-04-10 01:50:33 +00:00
|
|
|
|
|
2010-04-18 22:09:40 +00:00
|
|
|
|
count_expand_children (box, &nvis_children, &nexpand_children);
|
2010-04-10 01:50:33 +00:00
|
|
|
|
|
2010-08-06 20:07:42 +00:00
|
|
|
|
if (nvis_children <= 0)
|
|
|
|
|
return;
|
2010-04-10 01:50:33 +00:00
|
|
|
|
|
2016-12-10 02:47:53 +00:00
|
|
|
|
spacing = get_spacing (box);
|
2010-08-06 20:07:42 +00:00
|
|
|
|
sizes = g_newa (GtkRequestedSize, nvis_children);
|
2018-08-27 16:53:56 +00:00
|
|
|
|
extra_space = MAX (0, for_size - (nvis_children - 1) * spacing);
|
2010-04-10 01:50:33 +00:00
|
|
|
|
|
2010-08-06 20:07:42 +00:00
|
|
|
|
/* Retrieve desired size for visible children */
|
2018-02-06 21:19:30 +00:00
|
|
|
|
for (i = 0, child = _gtk_widget_get_first_child (widget);
|
|
|
|
|
child != NULL;
|
|
|
|
|
child = _gtk_widget_get_next_sibling (child))
|
2010-08-06 20:07:42 +00:00
|
|
|
|
{
|
2018-02-06 21:19:30 +00:00
|
|
|
|
if (_gtk_widget_get_visible (child))
|
2010-08-06 20:07:42 +00:00
|
|
|
|
{
|
2018-02-06 21:19:30 +00:00
|
|
|
|
gtk_widget_measure (child,
|
2018-02-07 19:03:25 +00:00
|
|
|
|
priv->orientation,
|
2016-10-29 14:35:16 +00:00
|
|
|
|
-1,
|
|
|
|
|
&sizes[i].minimum_size, &sizes[i].natural_size,
|
|
|
|
|
NULL, NULL);
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
2016-12-25 23:16:14 +00:00
|
|
|
|
children_minimum_size += sizes[i].minimum_size;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
i += 1;
|
2010-04-18 22:09:40 +00:00
|
|
|
|
}
|
2010-08-06 20:07:42 +00:00
|
|
|
|
}
|
2010-04-10 01:50:33 +00:00
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->homogeneous)
|
2010-08-06 20:07:42 +00:00
|
|
|
|
{
|
2016-12-25 23:16:14 +00:00
|
|
|
|
/* We still need to run the above loop to populate the minimum sizes for
|
|
|
|
|
* children that aren't going to fill.
|
2010-08-06 20:07:42 +00:00
|
|
|
|
*/
|
2016-12-25 23:16:14 +00:00
|
|
|
|
|
|
|
|
|
size_given_to_child = extra_space / nvis_children;
|
|
|
|
|
n_extra_widgets = extra_space % nvis_children;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Bring children up to size first */
|
2016-12-25 23:16:14 +00:00
|
|
|
|
extra_space -= children_minimum_size;
|
|
|
|
|
extra_space = MAX (0, extra_space);
|
|
|
|
|
extra_space = gtk_distribute_natural_allocation (extra_space, nvis_children, sizes);
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
|
|
|
|
/* Calculate space which hasn't distributed yet,
|
|
|
|
|
* and is available for expanding children.
|
|
|
|
|
*/
|
|
|
|
|
if (nexpand_children > 0)
|
2010-04-18 22:09:40 +00:00
|
|
|
|
{
|
2016-12-25 23:16:14 +00:00
|
|
|
|
size_given_to_child = extra_space / nexpand_children;
|
|
|
|
|
n_extra_widgets = extra_space % nexpand_children;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
}
|
2010-04-18 22:09:40 +00:00
|
|
|
|
else
|
2016-12-25 23:16:14 +00:00
|
|
|
|
{
|
|
|
|
|
size_given_to_child = 0;
|
|
|
|
|
}
|
2010-08-06 20:07:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-03-05 14:20:20 +00:00
|
|
|
|
have_baseline = FALSE;
|
2018-02-06 21:19:30 +00:00
|
|
|
|
for (i = 0, child = _gtk_widget_get_first_child (widget);
|
|
|
|
|
child != NULL;
|
|
|
|
|
child = _gtk_widget_get_next_sibling (child))
|
2010-08-06 20:07:42 +00:00
|
|
|
|
{
|
2018-02-06 21:19:30 +00:00
|
|
|
|
/* If widget is not visible, skip it. */
|
|
|
|
|
if (!_gtk_widget_get_visible (child))
|
|
|
|
|
continue;
|
2010-04-11 02:39:11 +00:00
|
|
|
|
|
2018-02-06 21:19:30 +00:00
|
|
|
|
/* Assign the child's size. */
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->homogeneous)
|
2018-02-06 21:19:30 +00:00
|
|
|
|
{
|
|
|
|
|
child_size = size_given_to_child;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
2018-02-06 21:19:30 +00:00
|
|
|
|
if (n_extra_widgets > 0)
|
|
|
|
|
{
|
|
|
|
|
child_size++;
|
|
|
|
|
n_extra_widgets--;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
child_size = sizes[i].minimum_size;
|
2010-08-06 23:58:29 +00:00
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (gtk_widget_compute_expand (child, priv->orientation))
|
2018-01-17 11:54:42 +00:00
|
|
|
|
{
|
2018-02-06 21:19:30 +00:00
|
|
|
|
child_size += size_given_to_child;
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
2018-01-17 11:54:42 +00:00
|
|
|
|
if (n_extra_widgets > 0)
|
|
|
|
|
{
|
|
|
|
|
child_size++;
|
|
|
|
|
n_extra_widgets--;
|
|
|
|
|
}
|
|
|
|
|
}
|
2018-02-06 21:19:30 +00:00
|
|
|
|
}
|
2010-04-11 02:39:11 +00:00
|
|
|
|
|
2018-02-06 21:19:30 +00:00
|
|
|
|
child_minimum_baseline = child_natural_baseline = -1;
|
|
|
|
|
/* Assign the child's position. */
|
|
|
|
|
gtk_widget_measure (child,
|
2018-02-07 19:03:25 +00:00
|
|
|
|
OPPOSITE_ORIENTATION (priv->orientation),
|
2018-02-06 21:19:30 +00:00
|
|
|
|
child_size,
|
|
|
|
|
&child_minimum, &child_natural,
|
|
|
|
|
&child_minimum_baseline, &child_natural_baseline);
|
2010-08-06 20:07:42 +00:00
|
|
|
|
|
2018-02-06 21:19:30 +00:00
|
|
|
|
if (child_minimum_baseline >= 0)
|
|
|
|
|
{
|
|
|
|
|
have_baseline = TRUE;
|
|
|
|
|
computed_minimum_below = MAX (computed_minimum_below, child_minimum - child_minimum_baseline);
|
|
|
|
|
computed_natural_below = MAX (computed_natural_below, child_natural - child_natural_baseline);
|
|
|
|
|
computed_minimum_above = MAX (computed_minimum_above, child_minimum_baseline);
|
|
|
|
|
computed_natural_above = MAX (computed_natural_above, child_natural_baseline);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
computed_minimum = MAX (computed_minimum, child_minimum);
|
|
|
|
|
computed_natural = MAX (computed_natural, child_natural);
|
|
|
|
|
}
|
|
|
|
|
i += 1;
|
2010-04-11 02:39:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-03-05 14:20:20 +00:00
|
|
|
|
if (have_baseline)
|
|
|
|
|
{
|
|
|
|
|
computed_minimum = MAX (computed_minimum, computed_minimum_below + computed_minimum_above);
|
|
|
|
|
computed_natural = MAX (computed_natural, computed_natural_below + computed_natural_above);
|
2018-02-07 19:03:25 +00:00
|
|
|
|
switch (priv->baseline_pos)
|
2013-03-05 14:20:20 +00:00
|
|
|
|
{
|
|
|
|
|
case GTK_BASELINE_POSITION_TOP:
|
|
|
|
|
computed_minimum_baseline = computed_minimum_above;
|
|
|
|
|
computed_natural_baseline = computed_natural_above;
|
|
|
|
|
break;
|
|
|
|
|
case GTK_BASELINE_POSITION_CENTER:
|
|
|
|
|
computed_minimum_baseline = computed_minimum_above + MAX((computed_minimum - (computed_minimum_above + computed_minimum_below)) / 2, 0);
|
|
|
|
|
computed_natural_baseline = computed_natural_above + MAX((computed_natural - (computed_natural_above + computed_natural_below)) / 2, 0);
|
|
|
|
|
break;
|
|
|
|
|
case GTK_BASELINE_POSITION_BOTTOM:
|
|
|
|
|
computed_minimum_baseline = computed_minimum - computed_minimum_below;
|
|
|
|
|
computed_natural_baseline = computed_natural - computed_natural_below;
|
|
|
|
|
break;
|
2017-10-06 19:19:42 +00:00
|
|
|
|
default:
|
|
|
|
|
break;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-18 22:09:40 +00:00
|
|
|
|
*minimum_size = computed_minimum;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
*natural_size = MAX (computed_natural, computed_natural_below + computed_natural_above);
|
2018-01-16 17:47:52 +00:00
|
|
|
|
|
|
|
|
|
*minimum_baseline = computed_minimum_baseline;
|
|
|
|
|
*natural_baseline = computed_natural_baseline;
|
2010-09-13 21:54:08 +00:00
|
|
|
|
}
|
2010-04-10 01:50:33 +00:00
|
|
|
|
|
2010-09-13 21:54:08 +00:00
|
|
|
|
static void
|
2010-04-10 01:50:33 +00:00
|
|
|
|
gtk_box_compute_size_for_orientation (GtkBox *box,
|
2018-08-27 16:48:09 +00:00
|
|
|
|
int for_size,
|
2018-08-27 16:45:03 +00:00
|
|
|
|
int *minimum_size,
|
|
|
|
|
int *natural_size)
|
2010-04-10 01:50:33 +00:00
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2018-02-06 21:11:01 +00:00
|
|
|
|
GtkWidget *child;
|
2018-08-27 16:45:03 +00:00
|
|
|
|
const int spacing = get_spacing (box);
|
|
|
|
|
int nvis_children = 0;
|
|
|
|
|
int required_size = 0, required_natural = 0;
|
|
|
|
|
int largest_child = 0, largest_natural = 0;
|
2010-04-10 01:50:33 +00:00
|
|
|
|
|
2018-02-06 21:11:01 +00:00
|
|
|
|
for (child = gtk_widget_get_first_child (GTK_WIDGET (box));
|
|
|
|
|
child != NULL;
|
|
|
|
|
child = gtk_widget_get_next_sibling (child))
|
2010-04-10 01:50:33 +00:00
|
|
|
|
{
|
2018-02-06 21:11:01 +00:00
|
|
|
|
if (_gtk_widget_get_visible (child))
|
2010-04-10 01:50:33 +00:00
|
|
|
|
{
|
2018-08-27 16:45:03 +00:00
|
|
|
|
int child_size, child_natural;
|
2010-04-10 01:50:33 +00:00
|
|
|
|
|
2018-02-06 21:11:01 +00:00
|
|
|
|
gtk_widget_measure (child,
|
2018-02-07 19:03:25 +00:00
|
|
|
|
priv->orientation,
|
2018-08-27 16:48:09 +00:00
|
|
|
|
for_size,
|
2016-10-29 14:35:16 +00:00
|
|
|
|
&child_size, &child_natural,
|
|
|
|
|
NULL, NULL);
|
2010-04-10 01:50:33 +00:00
|
|
|
|
|
2018-08-27 16:45:03 +00:00
|
|
|
|
largest_child = MAX (largest_child, child_size);
|
|
|
|
|
largest_natural = MAX (largest_natural, child_natural);
|
2010-04-10 01:50:33 +00:00
|
|
|
|
|
|
|
|
|
required_size += child_size;
|
|
|
|
|
required_natural += child_natural;
|
2011-03-06 04:25:35 +00:00
|
|
|
|
|
|
|
|
|
nvis_children += 1;
|
2010-04-10 01:50:33 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (nvis_children > 0)
|
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->homogeneous)
|
2010-04-10 01:50:33 +00:00
|
|
|
|
{
|
|
|
|
|
required_size = largest_child * nvis_children;
|
|
|
|
|
required_natural = largest_natural * nvis_children;
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-10 02:47:53 +00:00
|
|
|
|
required_size += (nvis_children - 1) * spacing;
|
|
|
|
|
required_natural += (nvis_children - 1) * spacing;
|
2010-04-10 01:50:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
2018-02-06 21:11:01 +00:00
|
|
|
|
*minimum_size = required_size;
|
|
|
|
|
*natural_size = required_natural;
|
2010-04-10 01:50:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-05-04 05:52:14 +00:00
|
|
|
|
|
2015-11-18 00:47:53 +00:00
|
|
|
|
static void
|
2017-05-04 05:52:14 +00:00
|
|
|
|
gtk_box_measure (GtkWidget *widget,
|
|
|
|
|
GtkOrientation orientation,
|
|
|
|
|
int for_size,
|
|
|
|
|
int *minimum,
|
|
|
|
|
int *natural,
|
|
|
|
|
int *minimum_baseline,
|
|
|
|
|
int *natural_baseline)
|
2015-11-18 00:47:53 +00:00
|
|
|
|
{
|
2018-08-27 16:53:56 +00:00
|
|
|
|
GtkBox *box = GTK_BOX (widget);
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2010-04-10 01:50:33 +00:00
|
|
|
|
|
2018-08-27 16:53:56 +00:00
|
|
|
|
if (priv->orientation != orientation)
|
|
|
|
|
gtk_box_compute_size_for_opposing_orientation (box, for_size, minimum, natural, minimum_baseline, natural_baseline);
|
2010-04-10 01:50:33 +00:00
|
|
|
|
else
|
2018-08-27 16:53:56 +00:00
|
|
|
|
gtk_box_compute_size_for_orientation (box, for_size, minimum, natural);
|
2013-03-05 14:20:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2015-11-18 00:47:53 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_box_init (GtkBox *box)
|
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2015-11-18 00:47:53 +00:00
|
|
|
|
|
2018-03-20 14:21:12 +00:00
|
|
|
|
gtk_widget_set_has_surface (GTK_WIDGET (box), FALSE);
|
2015-11-18 00:47:53 +00:00
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
priv->orientation = GTK_ORIENTATION_HORIZONTAL;
|
|
|
|
|
priv->children = NULL;
|
2015-11-18 00:47:53 +00:00
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
priv->homogeneous = FALSE;
|
|
|
|
|
priv->spacing = 0;
|
|
|
|
|
priv->baseline_pos = GTK_BASELINE_POSITION_CENTER;
|
2015-11-18 00:47:53 +00:00
|
|
|
|
|
|
|
|
|
_gtk_orientable_set_style_classes (GTK_ORIENTABLE (box));
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-07 07:44:06 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_box_new:
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* @orientation: the box’s orientation.
|
2008-10-07 07:44:06 +00:00
|
|
|
|
* @spacing: the number of pixels to place by default between children.
|
|
|
|
|
*
|
2010-05-30 03:31:50 +00:00
|
|
|
|
* Creates a new #GtkBox.
|
2008-10-07 07:44:06 +00:00
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: a new #GtkBox.
|
2008-10-07 07:44:06 +00:00
|
|
|
|
**/
|
2008-10-07 09:07:27 +00:00
|
|
|
|
GtkWidget*
|
2010-05-25 22:55:15 +00:00
|
|
|
|
gtk_box_new (GtkOrientation orientation,
|
|
|
|
|
gint spacing)
|
2008-10-07 07:44:06 +00:00
|
|
|
|
{
|
|
|
|
|
return g_object_new (GTK_TYPE_BOX,
|
|
|
|
|
"orientation", orientation,
|
|
|
|
|
"spacing", spacing,
|
|
|
|
|
NULL);
|
|
|
|
|
}
|
|
|
|
|
|
2007-06-10 02:53:17 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_box_pack_start:
|
|
|
|
|
* @box: a #GtkBox
|
|
|
|
|
* @child: the #GtkWidget to be added to @box
|
|
|
|
|
*
|
|
|
|
|
* Adds @child to @box, packed with reference to the start of @box.
|
2010-10-15 14:58:35 +00:00
|
|
|
|
* The @child is packed after any other child packed with reference
|
2007-06-10 02:53:17 +00:00
|
|
|
|
* to the start of @box.
|
|
|
|
|
*/
|
1997-11-24 22:37:52 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_box_pack_start (GtkBox *box,
|
2017-04-21 20:34:36 +00:00
|
|
|
|
GtkWidget *child)
|
1997-11-24 22:37:52 +00:00
|
|
|
|
{
|
2018-12-26 08:49:10 +00:00
|
|
|
|
gtk_box_pack (box, child);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-06-10 02:53:17 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_box_pack_end:
|
|
|
|
|
* @box: a #GtkBox
|
|
|
|
|
* @child: the #GtkWidget to be added to @box
|
|
|
|
|
*
|
2010-11-02 09:43:42 +00:00
|
|
|
|
* Adds @child to @box, packed with reference to the end of @box.
|
|
|
|
|
* The @child is packed after (away from end of) any other child
|
2007-06-10 02:53:17 +00:00
|
|
|
|
* packed with reference to the end of @box.
|
|
|
|
|
*/
|
1997-11-24 22:37:52 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_box_pack_end (GtkBox *box,
|
2017-04-21 20:34:36 +00:00
|
|
|
|
GtkWidget *child)
|
1997-11-24 22:37:52 +00:00
|
|
|
|
{
|
2018-12-26 08:49:10 +00:00
|
|
|
|
gtk_box_pack (box, child);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-06-10 02:53:17 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_box_set_homogeneous:
|
|
|
|
|
* @box: a #GtkBox
|
|
|
|
|
* @homogeneous: a boolean value, %TRUE to create equal allotments,
|
|
|
|
|
* %FALSE for variable allotments
|
2010-11-02 09:43:42 +00:00
|
|
|
|
*
|
|
|
|
|
* Sets the #GtkBox:homogeneous property of @box, controlling
|
|
|
|
|
* whether or not all children of @box are given equal space
|
2007-06-10 02:53:17 +00:00
|
|
|
|
* in the box.
|
|
|
|
|
*/
|
1997-11-24 22:37:52 +00:00
|
|
|
|
void
|
1998-06-16 05:20:05 +00:00
|
|
|
|
gtk_box_set_homogeneous (GtkBox *box,
|
|
|
|
|
gboolean homogeneous)
|
1997-11-24 22:37:52 +00:00
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2010-05-24 23:11:54 +00:00
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_BOX (box));
|
|
|
|
|
|
2014-06-07 14:59:14 +00:00
|
|
|
|
homogeneous = homogeneous != FALSE;
|
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->homogeneous != homogeneous)
|
1997-11-24 22:37:52 +00:00
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
priv->homogeneous = homogeneous;
|
2014-06-07 14:59:14 +00:00
|
|
|
|
g_object_notify_by_pspec (G_OBJECT (box), props[PROP_HOMOGENEOUS]);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (box));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2001-06-24 15:34:48 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_box_get_homogeneous:
|
|
|
|
|
* @box: a #GtkBox
|
|
|
|
|
*
|
|
|
|
|
* Returns whether the box is homogeneous (all children are the
|
2007-05-26 06:59:36 +00:00
|
|
|
|
* same size). See gtk_box_set_homogeneous().
|
2001-06-24 15:34:48 +00:00
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: %TRUE if the box is homogeneous.
|
2001-06-24 15:34:48 +00:00
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
gtk_box_get_homogeneous (GtkBox *box)
|
|
|
|
|
{
|
2017-10-06 12:24:52 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
|
|
|
|
|
2001-06-24 15:34:48 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_BOX (box), FALSE);
|
|
|
|
|
|
2017-10-06 12:24:52 +00:00
|
|
|
|
return priv->homogeneous;
|
2001-06-24 15:34:48 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-06-10 02:53:17 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_box_set_spacing:
|
|
|
|
|
* @box: a #GtkBox
|
|
|
|
|
* @spacing: the number of pixels to put between children
|
|
|
|
|
*
|
2010-11-02 09:43:42 +00:00
|
|
|
|
* Sets the #GtkBox:spacing property of @box, which is the
|
2007-06-10 02:53:17 +00:00
|
|
|
|
* number of pixels to place between children of @box.
|
|
|
|
|
*/
|
1997-11-24 22:37:52 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_box_set_spacing (GtkBox *box,
|
|
|
|
|
gint spacing)
|
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2010-05-24 23:11:54 +00:00
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_BOX (box));
|
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->spacing != spacing)
|
1997-11-24 22:37:52 +00:00
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
priv->spacing = spacing;
|
2008-09-24 08:41:46 +00:00
|
|
|
|
|
2014-06-07 14:59:14 +00:00
|
|
|
|
g_object_notify_by_pspec (G_OBJECT (box), props[PROP_SPACING]);
|
2008-09-24 08:41:46 +00:00
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (box));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2001-03-07 21:10:44 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_box_get_spacing:
|
|
|
|
|
* @box: a #GtkBox
|
2010-11-02 09:43:42 +00:00
|
|
|
|
*
|
2001-03-07 21:10:44 +00:00
|
|
|
|
* Gets the value set by gtk_box_set_spacing().
|
2010-11-02 09:43:42 +00:00
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: spacing between children
|
2001-03-07 21:10:44 +00:00
|
|
|
|
**/
|
|
|
|
|
gint
|
|
|
|
|
gtk_box_get_spacing (GtkBox *box)
|
|
|
|
|
{
|
2017-10-06 12:24:52 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2001-03-09 14:49:00 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_BOX (box), 0);
|
2001-03-07 21:10:44 +00:00
|
|
|
|
|
2017-10-06 12:24:52 +00:00
|
|
|
|
return priv->spacing;
|
2001-03-07 21:10:44 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-03-05 14:20:20 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_box_set_baseline_position:
|
|
|
|
|
* @box: a #GtkBox
|
|
|
|
|
* @position: a #GtkBaselinePosition
|
|
|
|
|
*
|
|
|
|
|
* Sets the baseline position of a box. This affects
|
|
|
|
|
* only horizontal boxes with at least one baseline aligned
|
2014-01-28 04:30:28 +00:00
|
|
|
|
* child. If there is more vertical space available than requested,
|
2013-03-05 14:20:20 +00:00
|
|
|
|
* and the baseline is not allocated by the parent then
|
|
|
|
|
* @position is used to allocate the baseline wrt the
|
|
|
|
|
* extra space available.
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gtk_box_set_baseline_position (GtkBox *box,
|
|
|
|
|
GtkBaselinePosition position)
|
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2013-03-05 14:20:20 +00:00
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_BOX (box));
|
|
|
|
|
|
2018-02-07 19:03:25 +00:00
|
|
|
|
if (priv->baseline_pos != position)
|
2013-03-05 14:20:20 +00:00
|
|
|
|
{
|
2018-02-07 19:03:25 +00:00
|
|
|
|
priv->baseline_pos = position;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
|
2014-06-07 14:59:14 +00:00
|
|
|
|
g_object_notify_by_pspec (G_OBJECT (box), props[PROP_BASELINE_POSITION]);
|
2013-03-05 14:20:20 +00:00
|
|
|
|
|
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (box));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_box_get_baseline_position:
|
|
|
|
|
* @box: a #GtkBox
|
|
|
|
|
*
|
|
|
|
|
* Gets the value set by gtk_box_set_baseline_position().
|
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: the baseline position
|
2013-03-05 14:20:20 +00:00
|
|
|
|
**/
|
|
|
|
|
GtkBaselinePosition
|
2014-06-07 14:59:14 +00:00
|
|
|
|
gtk_box_get_baseline_position (GtkBox *box)
|
2013-03-05 14:20:20 +00:00
|
|
|
|
{
|
2017-10-06 12:24:52 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
|
|
|
|
|
2013-03-05 14:20:20 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_BOX (box), GTK_BASELINE_POSITION_CENTER);
|
|
|
|
|
|
2017-10-06 12:24:52 +00:00
|
|
|
|
return priv->baseline_pos;
|
2013-03-05 14:20:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-06-10 02:53:17 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_box_reorder_child:
|
|
|
|
|
* @box: a #GtkBox
|
|
|
|
|
* @child: the #GtkWidget to move
|
2010-11-02 09:43:42 +00:00
|
|
|
|
* @position: the new position for @child in the list of children
|
|
|
|
|
* of @box, starting from 0. If negative, indicates the end of
|
2007-06-10 02:53:17 +00:00
|
|
|
|
* the list
|
|
|
|
|
*
|
2010-11-02 09:43:42 +00:00
|
|
|
|
* Moves @child to a new @position in the list of @box children.
|
2014-01-27 22:13:43 +00:00
|
|
|
|
* The list contains widgets packed #GTK_PACK_START
|
2010-11-02 09:43:42 +00:00
|
|
|
|
* as well as widgets packed #GTK_PACK_END, in the order that these
|
2007-06-10 02:53:17 +00:00
|
|
|
|
* widgets were added to @box.
|
2010-11-02 09:43:42 +00:00
|
|
|
|
*
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* A widget’s position in the @box children list determines where
|
2010-11-02 09:43:42 +00:00
|
|
|
|
* the widget is packed into @box. A child widget at some position
|
|
|
|
|
* in the list will be packed just after all other widgets of the
|
2007-06-10 02:53:17 +00:00
|
|
|
|
* same packing type that appear earlier in the list.
|
2010-11-02 09:43:42 +00:00
|
|
|
|
*/
|
1998-01-18 03:09:42 +00:00
|
|
|
|
void
|
fix PROP_EVENTS.
Mon Jun 18 02:00:49 2001 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_get_property): fix PROP_EVENTS.
* gtk/Makefile.am:
* gtk/gtk.h: disabled GtkPacker compilation.
* gtk/gtkarg.[hc], gtk/gtkargcollector.c: got rid of these.
* gtk/gtknotebook.c:
* gtk/gtktable.c:
* gtk/gtkbox.c: ported this over to child properties.
* gtk/gtksettings.c: fetch class properties via
g_object_class_list_properties().
* gtk/gtkcontainer.[hc]: implemented child properties, got rid of the
child arg interface. use gobjectnotifyqueue.c for child property
notification.
* gtk/gtkwidget.[hc]: provide necessary means for container child
properties, i.e. ::child_notify signal,
gtk_widget_freeze_child_notify(),
gtk_widget_child_notify(),
gtk_widget_thaw_child_notify().
* tests/testgtk.c: removed inferior property handling code, for
property editing, a generic module should be used, and GLE
coincidentally fullfills that purpose.
* docs/reference/Makefile.am: disabled gtk docs building, gtk-doc
needs to be adapted to g_object_class_list_properties() before this
builds again.
2001-06-19 12:54:10 +00:00
|
|
|
|
gtk_box_reorder_child (GtkBox *box,
|
|
|
|
|
GtkWidget *child,
|
|
|
|
|
gint position)
|
1998-01-18 03:09:42 +00:00
|
|
|
|
{
|
2017-10-06 12:24:52 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2002-02-27 03:35:05 +00:00
|
|
|
|
GList *old_link;
|
|
|
|
|
GList *new_link;
|
|
|
|
|
GtkBoxChild *child_info = NULL;
|
|
|
|
|
gint old_position;
|
1998-01-18 03:09:42 +00:00
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_BOX (box));
|
2002-01-30 22:29:03 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
1998-01-18 03:09:42 +00:00
|
|
|
|
|
2010-05-24 23:11:54 +00:00
|
|
|
|
old_link = priv->children;
|
2002-02-27 03:35:05 +00:00
|
|
|
|
old_position = 0;
|
|
|
|
|
while (old_link)
|
1998-01-18 03:09:42 +00:00
|
|
|
|
{
|
2002-02-27 03:35:05 +00:00
|
|
|
|
child_info = old_link->data;
|
1998-01-18 03:09:42 +00:00
|
|
|
|
if (child_info->widget == child)
|
|
|
|
|
break;
|
|
|
|
|
|
2002-02-27 03:35:05 +00:00
|
|
|
|
old_link = old_link->next;
|
|
|
|
|
old_position++;
|
1998-01-18 03:09:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-27 03:35:05 +00:00
|
|
|
|
g_return_if_fail (old_link != NULL);
|
1998-01-18 03:09:42 +00:00
|
|
|
|
|
2002-02-27 03:35:05 +00:00
|
|
|
|
if (position == old_position)
|
|
|
|
|
return;
|
1998-01-18 03:09:42 +00:00
|
|
|
|
|
2010-05-24 23:11:54 +00:00
|
|
|
|
priv->children = g_list_delete_link (priv->children, old_link);
|
1998-01-18 03:09:42 +00:00
|
|
|
|
|
2002-02-27 03:35:05 +00:00
|
|
|
|
if (position < 0)
|
|
|
|
|
new_link = NULL;
|
|
|
|
|
else
|
2010-05-24 23:11:54 +00:00
|
|
|
|
new_link = g_list_nth (priv->children, position);
|
1998-01-18 03:09:42 +00:00
|
|
|
|
|
2010-05-24 23:11:54 +00:00
|
|
|
|
priv->children = g_list_insert_before (priv->children, new_link, child_info);
|
2015-11-09 00:29:56 +00:00
|
|
|
|
gtk_box_update_child_css_position (box, child_info);
|
2002-02-27 03:35:05 +00:00
|
|
|
|
|
2015-09-07 22:27:02 +00:00
|
|
|
|
gtk_container_child_notify_by_pspec (GTK_CONTAINER (box), child, child_props[CHILD_PROP_POSITION]);
|
2015-09-06 23:58:03 +00:00
|
|
|
|
if (_gtk_widget_get_visible (child) &&
|
|
|
|
|
_gtk_widget_get_visible (GTK_WIDGET (box)))
|
2011-05-25 21:38:59 +00:00
|
|
|
|
{
|
|
|
|
|
gtk_widget_queue_resize (child);
|
|
|
|
|
}
|
1998-01-18 03:09:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_box_add (GtkContainer *container,
|
|
|
|
|
GtkWidget *widget)
|
|
|
|
|
{
|
2017-04-21 20:34:36 +00:00
|
|
|
|
gtk_box_pack_start (GTK_BOX (container), widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_box_remove (GtkContainer *container,
|
|
|
|
|
GtkWidget *widget)
|
|
|
|
|
{
|
2008-02-07 15:50:39 +00:00
|
|
|
|
GtkBox *box = GTK_BOX (container);
|
2017-10-06 12:24:52 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
GtkBoxChild *child;
|
|
|
|
|
GList *children;
|
|
|
|
|
|
2010-05-24 23:11:54 +00:00
|
|
|
|
children = priv->children;
|
1997-11-24 22:37:52 +00:00
|
|
|
|
while (children)
|
|
|
|
|
{
|
|
|
|
|
child = children->data;
|
|
|
|
|
|
|
|
|
|
if (child->widget == widget)
|
|
|
|
|
{
|
1998-06-24 17:15:05 +00:00
|
|
|
|
gboolean was_visible;
|
1998-03-24 03:34:38 +00:00
|
|
|
|
|
2015-09-06 23:58:03 +00:00
|
|
|
|
was_visible = _gtk_widget_get_visible (widget);
|
2012-02-16 01:36:06 +00:00
|
|
|
|
gtk_widget_unparent (widget);
|
|
|
|
|
|
2010-05-24 23:11:54 +00:00
|
|
|
|
priv->children = g_list_remove_link (priv->children, children);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
g_list_free (children);
|
|
|
|
|
g_free (child);
|
|
|
|
|
|
2010-03-01 06:47:38 +00:00
|
|
|
|
/* queue resize regardless of gtk_widget_get_visible (container),
|
1998-06-24 17:15:05 +00:00
|
|
|
|
* since that's what is needed by toplevels.
|
|
|
|
|
*/
|
|
|
|
|
if (was_visible)
|
2011-05-25 21:38:59 +00:00
|
|
|
|
{
|
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (container));
|
|
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
children = children->next;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
GTK_MENU_DIR_CHILD: check for the existance of
Thu Sep 3 04:22:20 1998 Tim Janik <timj@gtk.org>
* gtk/gtkmenushell.c (gtk_real_menu_shell_move_current):
GTK_MENU_DIR_CHILD: check for the existance of
menu_shell->active_menu_item before accessing its child.
GTK_MENU_DIR_PREV:
GTK_MENU_DIR_NEXT: if we haven't had an active item and still
don't, make a default selection.
Wed Sep 2 00:28:58 1998 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_propagate_state): iterate
the children with _forall for sensitivity changes and with
_foreach on pure state changes. this fixes a lot of the
old inclusions of internal widgets into _foreach calls.
* gtk/gtktree.c: removed gtk_tree_foreach, let gtk_tree_forall
do the work. don't walk the subtrees of first level children.
* gtk/gtktreeitem.c: provide a _forall implementation,
which walks the subtrees as well for include_internals.
* gtk/gtkmenuitem.c: provide a _forall implementation, which walks
the submenus as well for include_internals.
* gtk/gtkscrolledwindow.c: removed gtk_scrolled_window_foreach and
implemented gtk_scrolled_window_forall, which will iterate over
the viewport and the scrollbars for gtk_container_forall or
iterate over the viewports children for gtk_container_foreach.
* gtk/gtktoolbar.c:
* gtk/gtktable.c:
* gtk/gtkpaned.c:
* gtk/gtkpacker.c:
* gtk/gtkmenushell.c:
* gtk/gtklist.c:
* gtk/gtkfixed.c:
* gtk/gtkclist.c:
* gtk/gtkbox.c:
* gtk/gtkbin.c:
* gtk/gtknotebook.c:
removed the old gtk_*_foreach functions and provided gtk_*_forall.
* gtk/gtknotebook.c:
(gtk_notebook_real_switch_page): expose tabs.
(gtk_notebook_page_num): new function to return the page number
of a distinct child.
(gtk_notebook_focus): minor fixups. foxus handling is still screwed
under some circumstances.
* gtk/gtktreeitem.c:
(gtk_real_tree_item_select):
(gtk_real_tree_item_deselect): major fixes.
some general fixups wrt queue_redraw, and tree items not being
NO_WINDOW widgets.
* gtk/gtklistitem.c:
(gtk_real_list_item_select):
(gtk_real_list_item_deselect):
(gtk_real_list_item_toggle):
removed unneccessary queue_redraw calls.
Wed Aug 30 09:42:07 1998 Tim Janik <timj@gtk.org>
* gtk/gtkoptionmenu.c: allow optionmenus to have the focus and
automatically popup the menu on space bar.
Wed Aug 26 06:40:34 1998 Tim Janik <timj@gtk.org>
* gtk/gtkcontainer.h:
* gtk/gtkcontainer.c: implemented gtk_container_forall() (as a class
method), which acts similar to gtk_container_foreach(), but iterates
over internal children. the GtkContainer::foreach signal vanished in
favour of a new class method ->forall() that optionally includes
internal widgets.
* gtk/gtkclist.c (gtk_clist_init): provide no _foreach implementation
but a _forall implementation, since all child widgets we have are
internal ones.
(column_button_create): set the parent window prior
to gtk_widget_set_parent().
* gtk/gtkwidget.c:
exchanged all calls to gtk_container_foreach() with
gtk_container_forall().
* gtk/gtkwidget.h:
* gtk/gtkwidget.c: added the GTK_COMPOSITE_CHILD, exported through
the GtkWidget::composite_child argument. to have a widget created
with the flag initially, two new functions got added to wrap a widgets
creation:
gtk_widget_push_composite_flag() and gtk_widget_pop_composite_flag().
Wed Aug 25 23:37:39 1998 Tim Janik <timj@gtk.org>
* gtk/gtktooltips.h:
* gtk/gtktooltips.c: exported gtk_tooltips_create_window() as
gtk_tooltips_force_window(), so tooltips->tip_window can be accessed
prior to the first tip being set.
don't put an extra reference on the window, since it is a toplevel,
it wont get destroyed from anywhere else.
* overall macro and GtkType fixups.
1998-09-03 02:38:53 +00:00
|
|
|
|
gtk_box_forall (GtkContainer *container,
|
|
|
|
|
GtkCallback callback,
|
|
|
|
|
gpointer callback_data)
|
1997-11-24 22:37:52 +00:00
|
|
|
|
{
|
2008-02-07 15:50:39 +00:00
|
|
|
|
GtkBox *box = GTK_BOX (container);
|
2017-10-06 12:24:52 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
GtkBoxChild *child;
|
|
|
|
|
GList *children;
|
|
|
|
|
|
2010-05-24 23:11:54 +00:00
|
|
|
|
children = priv->children;
|
1997-11-24 22:37:52 +00:00
|
|
|
|
while (children)
|
|
|
|
|
{
|
|
|
|
|
child = children->data;
|
|
|
|
|
children = children->next;
|
|
|
|
|
|
|
|
|
|
if (child->pack == GTK_PACK_START)
|
|
|
|
|
(* callback) (child->widget, callback_data);
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-17 03:57:24 +00:00
|
|
|
|
|
2010-05-24 23:11:54 +00:00
|
|
|
|
children = g_list_last (priv->children);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
while (children)
|
|
|
|
|
{
|
|
|
|
|
child = children->data;
|
|
|
|
|
children = children->prev;
|
|
|
|
|
|
|
|
|
|
if (child->pack == GTK_PACK_END)
|
|
|
|
|
(* callback) (child->widget, callback_data);
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-07-26 13:24:15 +00:00
|
|
|
|
|
2016-02-12 12:21:14 +00:00
|
|
|
|
GList *
|
|
|
|
|
_gtk_box_get_children (GtkBox *box)
|
|
|
|
|
{
|
2017-10-06 12:24:52 +00:00
|
|
|
|
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
|
2016-02-12 12:21:14 +00:00
|
|
|
|
GtkBoxChild *child;
|
|
|
|
|
GList *children;
|
|
|
|
|
GList *retval = NULL;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (GTK_IS_BOX (box), NULL);
|
|
|
|
|
|
|
|
|
|
children = priv->children;
|
|
|
|
|
while (children)
|
|
|
|
|
{
|
|
|
|
|
child = children->data;
|
|
|
|
|
children = children->next;
|
|
|
|
|
|
|
|
|
|
retval = g_list_prepend (retval, child->widget);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return g_list_reverse (retval);
|
|
|
|
|
}
|