AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-26 13:41:07 +00:00
Code Issues Projects Releases Wiki Activity
36f914f02d
gtk/gtk/gtkpacker.c
Hans Breuer 0b5db507da coalescing property notifies 
2001-08-11  Hans Breuer  <hans@breuer.org>

	* gtk/gtkalignment.c, gtk/gtkarrow.c, gtk/gtkaspectframe.c,
	  gtk/gtkcellrenderer.c, gtk/gtkcellrenderertext.c,
	  gtk/gtkcombo.c, gtk/gtkcurve.c, gtk/gtkfontsel.c,
	  gtk/gtklayout.c, gtk/gtkmisc.c, gtk/gtkpacker.c,
	  gtk/gtkprogress.c, gtk/gtkruler.c,, gtk/gtksettings.c,
	  gtk/gtkspinbutton.c, gtk/gtktexttag.c : coalescing property notifies

	* gtk/gtkclist.c, gtk/gtktipsquery.c, gtk/gtktexttag.c,
	  gtk/gtkwidget.c : added G_SIGNAL_TYPE_STATIC_SCOPE to all
	GDK_TYPE_EVENT signals

	* gtk/gtkalignment.c : removed 'direct allocation bug',
	which Tim discovered while reading the patch
2001-08-11 20:27:36 +00:00

1236 lines
34 KiB
C
Raw Blame History

/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* GtkPacker Widget
* Copyright (C) 1998 Shawn T. Amundson, James S. Mitchell, Michael L. Staiger
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
* This file contains modified code derived from Tk 8.0. Below is the header of
* the relevant file. The file 'license.terms' is included inline below.
*
* tkPack.c --
*
* This file contains code to implement the "packer"
* geometry manager for Tk.
*
* Copyright (c) 1990-1994 The Regents of the University of California.
* Copyright (c) 1994-1995 Sun Microsystems, Inc.
*
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
* SCCS: @(#) tkPack.c 1.64 96/05/03 10:51:52
*
* The file license.terms is below. NOTE: THE FOLLOWING APPLIES ONLY TO
* PORTIONS DERIVED FROM TK 8.0. THE LICENSE FOR THIS FILE IS LGPL, AS
* STATED ABOVE AND ALLOWED BELOW.
-- BEGIN license.terms --
This software is copyrighted by the Regents of the University of
California, Sun Microsystems, Inc., and other parties. The following
terms apply to all files associated with the software unless explicitly
disclaimed in individual files.
The authors hereby grant permission to use, copy, modify, distribute,
and license this software and its documentation for any purpose, provided
that existing copyright notices are retained in all copies and that this
notice is included verbatim in any distributions. No written agreement,
license, or royalty fee is required for any of the authorized uses.
Modifications to this software may be copyrighted by their authors
and need not follow the licensing terms described here, provided that
the new terms are clearly indicated on the first page of each file where
they apply.
IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.
GOVERNMENT USE: If you are acquiring this software on behalf of the
U.S. government, the Government shall have only "Restricted Rights"
in the software and related documentation as defined in the Federal
Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you
are acquiring the software on behalf of the Department of Defense, the
software shall be classified as "Commercial Computer Software" and the
Government shall have only "Restricted Rights" as defined in Clause
252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the
authors grant the U.S. Government and others acting in its behalf
permission to use and distribute the software in accordance with the
terms specified in this license.
-- END license.terms --
*
*/
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "gtkpacker.h"
#include "gtkintl.h"
enum {
PROP_0,
PROP_SPACING,
PROP_D_BORDER_WIDTH,
PROP_D_PAD_X,
PROP_D_PAD_Y,
PROP_D_IPAD_X,
PROP_D_IPAD_Y
};
enum {
CHILD_ARG_0,
CHILD_ARG_SIDE,
CHILD_ARG_ANCHOR,
CHILD_ARG_EXPAND,
CHILD_ARG_FILL_X,
CHILD_ARG_FILL_Y,
CHILD_ARG_USE_DEFAULT,
CHILD_ARG_BORDER_WIDTH,
CHILD_ARG_PAD_X,
CHILD_ARG_PAD_Y,
CHILD_ARG_I_PAD_X,
CHILD_ARG_I_PAD_Y,
CHILD_ARG_POSITION
};
static void gtk_packer_class_init (GtkPackerClass *klass);
static void gtk_packer_init (GtkPacker *packer);
static void gtk_packer_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static void gtk_packer_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static void gtk_packer_container_add (GtkContainer *container,
GtkWidget *child);
static void gtk_packer_remove (GtkContainer *container,
GtkWidget *widget);
static void gtk_packer_forall (GtkContainer *container,
gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
static void gtk_packer_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gtk_packer_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void gtk_packer_get_child_arg (GtkContainer *container,
GtkWidget *child,
GtkArg *arg,
guint arg_id);
static void gtk_packer_set_child_arg (GtkContainer *container,
GtkWidget *child,
GtkArg *arg,
guint arg_id);
static GtkType gtk_packer_child_type (GtkContainer *container);
static GtkPackerClass *parent_class;
GtkType
gtk_packer_get_type (void)
{
static GtkType packer_type = 0;
if (!packer_type)
{
static const GtkTypeInfo packer_info =
{
"GtkPacker",
sizeof (GtkPacker),
sizeof (GtkPackerClass),
(GtkClassInitFunc) gtk_packer_class_init,
(GtkObjectInitFunc) gtk_packer_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
packer_type = gtk_type_unique (GTK_TYPE_CONTAINER, &packer_info);
}
return packer_type;
}
static void
gtk_packer_class_init (GtkPackerClass *klass)
{
GtkObjectClass *object_class;
GObjectClass *gobject_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
gobject_class = G_OBJECT_CLASS (klass);
object_class = (GtkObjectClass*) klass;
widget_class = (GtkWidgetClass*) klass;
container_class = (GtkContainerClass*) klass;
parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
gtk_container_add_child_arg_type ("GtkPacker::side", GTK_TYPE_SIDE_TYPE, GTK_ARG_READWRITE, CHILD_ARG_SIDE);
gtk_container_add_child_arg_type ("GtkPacker::anchor", GTK_TYPE_ANCHOR_TYPE, GTK_ARG_READWRITE, CHILD_ARG_ANCHOR);
gtk_container_add_child_arg_type ("GtkPacker::expand", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_EXPAND);
gtk_container_add_child_arg_type ("GtkPacker::fill_x", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_FILL_X);
gtk_container_add_child_arg_type ("GtkPacker::fill_y", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_FILL_Y);
gtk_container_add_child_arg_type ("GtkPacker::use_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_USE_DEFAULT);
gtk_container_add_child_arg_type ("GtkPacker::border_width", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_BORDER_WIDTH);
gtk_container_add_child_arg_type ("GtkPacker::pad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_PAD_X);
gtk_container_add_child_arg_type ("GtkPacker::pad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_PAD_Y);
gtk_container_add_child_arg_type ("GtkPacker::ipad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_I_PAD_X);
gtk_container_add_child_arg_type ("GtkPacker::ipad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_I_PAD_Y);
gtk_container_add_child_arg_type ("GtkPacker::position", GTK_TYPE_INT, GTK_ARG_READWRITE, CHILD_ARG_POSITION);
gobject_class->set_property = gtk_packer_set_property;
gobject_class->get_property = gtk_packer_get_property;
widget_class->size_request = gtk_packer_size_request;
widget_class->size_allocate = gtk_packer_size_allocate;
container_class->add = gtk_packer_container_add;
container_class->remove = gtk_packer_remove;
container_class->forall = gtk_packer_forall;
container_class->child_type = gtk_packer_child_type;
container_class->get_child_arg = gtk_packer_get_child_arg;
container_class->set_child_arg = gtk_packer_set_child_arg;
g_object_class_install_property (gobject_class,
PROP_SPACING,
g_param_spec_uint ("spacing",
_("Spacing"),
_("Width between child elements"),
0,
G_MAXUINT,
0,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_D_BORDER_WIDTH,
g_param_spec_uint ("default_border_width",
_("Default Border"),
_("Default border width"),
0,
G_MAXUINT,
0,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_D_PAD_X,
g_param_spec_uint ("default_pad_x",
_("Default Pad X"),
_("Default horizontal padding"),
0,
G_MAXUINT,
0,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_D_PAD_Y,
g_param_spec_uint ("default_pad_y",
_("Default Pad Y"),
_("Default vertical padding"),
0,
G_MAXUINT,
0,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_D_IPAD_X,
g_param_spec_uint ("default_ipad_x",
_("Default IPad X"),
_("Default horizontal internal padding"),
0,
G_MAXUINT,
0,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_D_IPAD_Y,
g_param_spec_uint ("default_ipad_y",
_("Default IPad Y"),
_("Default vertical internal padding"),
0,
G_MAXUINT,
0,
G_PARAM_READWRITE));
}
static void
gtk_packer_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkPacker *packer;
packer = GTK_PACKER (object);
switch (prop_id)
{
case PROP_SPACING:
gtk_packer_set_spacing (packer, g_value_get_uint (value));
break;
case PROP_D_BORDER_WIDTH:
gtk_packer_set_default_border_width (packer, g_value_get_uint (value));
break;
case PROP_D_PAD_X:
gtk_packer_set_default_pad (packer,
g_value_get_uint (value),
packer->default_pad_y);
break;
case PROP_D_PAD_Y:
gtk_packer_set_default_pad (packer,
packer->default_pad_x,
g_value_get_uint (value));
break;
case PROP_D_IPAD_X:
gtk_packer_set_default_ipad (packer,
g_value_get_uint (value),
packer->default_i_pad_y);
break;
case PROP_D_IPAD_Y:
gtk_packer_set_default_ipad (packer,
packer->default_i_pad_x,
g_value_get_uint (value));
break;
default:
break;
}
}
static void
gtk_packer_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkPacker *packer;
packer = GTK_PACKER (object);
switch (prop_id)
{
case PROP_SPACING:
g_value_set_uint (value, packer->spacing);
break;
case PROP_D_BORDER_WIDTH:
g_value_set_uint (value, packer->default_border_width);
break;
case PROP_D_PAD_X:
g_value_set_uint (value, packer->default_pad_x);
break;
case PROP_D_PAD_Y:
g_value_set_uint (value, packer->default_pad_y);
break;
case PROP_D_IPAD_X:
g_value_set_uint (value, packer->default_i_pad_x);
break;
case PROP_D_IPAD_Y:
g_value_set_uint (value, packer->default_i_pad_y);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GtkType
gtk_packer_child_type (GtkContainer *container)
{
return GTK_TYPE_WIDGET;
}
static void
gtk_packer_set_child_arg (GtkContainer *container,
GtkWidget *child,
GtkArg *arg,
guint arg_id)
{
GtkPacker *packer;
GtkPackerChild *child_info = NULL;
packer = GTK_PACKER (container);
if (arg_id != CHILD_ARG_POSITION)
{
GList *list;
list = packer->children;
while (list)
{
child_info = list->data;
if (child_info->widget == child)
break;
list = list->next;
}
if (!list)
return;
}
switch (arg_id)
{
case CHILD_ARG_SIDE:
child_info->side = GTK_VALUE_ENUM (*arg);
break;
case CHILD_ARG_ANCHOR:
child_info->anchor = GTK_VALUE_ENUM (*arg);
break;
case CHILD_ARG_EXPAND:
if (GTK_VALUE_BOOL (*arg))
child_info->options |= GTK_PACK_EXPAND;
else
child_info->options &= ~GTK_PACK_EXPAND;
break;
case CHILD_ARG_FILL_X:
if (GTK_VALUE_BOOL (*arg))
child_info->options |= GTK_FILL_X;
else
child_info->options &= ~GTK_FILL_X;
break;
case CHILD_ARG_FILL_Y:
if (GTK_VALUE_BOOL (*arg))
child_info->options |= GTK_FILL_Y;
else
child_info->options &= ~GTK_FILL_Y;
break;
case CHILD_ARG_USE_DEFAULT:
child_info->use_default = (GTK_VALUE_BOOL (*arg) != 0);
break;
case CHILD_ARG_BORDER_WIDTH:
if (!child_info->use_default)
child_info->border_width = GTK_VALUE_UINT (*arg);
break;
case CHILD_ARG_PAD_X:
if (!child_info->use_default)
child_info->pad_x = GTK_VALUE_UINT (*arg);
break;
case CHILD_ARG_PAD_Y:
if (!child_info->use_default)
child_info->pad_y = GTK_VALUE_UINT (*arg);
break;
case CHILD_ARG_I_PAD_X:
if (!child_info->use_default)
child_info->i_pad_x = GTK_VALUE_UINT (*arg);
break;
case CHILD_ARG_I_PAD_Y:
if (!child_info->use_default)
child_info->i_pad_y = GTK_VALUE_UINT (*arg);
break;
case CHILD_ARG_POSITION:
gtk_packer_reorder_child (packer,
child,
GTK_VALUE_INT (*arg));
break;
default:
break;
}
if (arg_id != CHILD_ARG_POSITION &&
GTK_WIDGET_VISIBLE (packer) &&
GTK_WIDGET_VISIBLE (child))
gtk_widget_queue_resize (child);
}
static void
gtk_packer_get_child_arg (GtkContainer *container,
GtkWidget *child,
GtkArg *arg,
guint arg_id)
{
GtkPacker *packer;
GtkPackerChild *child_info = NULL;
GList * list;
packer = GTK_PACKER (container);
if (arg_id != CHILD_ARG_POSITION)
{
list = packer->children;
while (list)
{
child_info = list->data;
if (child_info->widget == child)
break;
list = list->next;
}
if (!list)
{
arg->type = GTK_TYPE_INVALID;
return;
}
}
switch (arg_id)
{
case CHILD_ARG_SIDE:
GTK_VALUE_ENUM (*arg) = child_info->side;
break;
case CHILD_ARG_ANCHOR:
GTK_VALUE_ENUM (*arg) = child_info->anchor;
break;
case CHILD_ARG_EXPAND:
GTK_VALUE_BOOL (*arg) = (child_info->options & GTK_PACK_EXPAND) != 0;
break;
case CHILD_ARG_FILL_X:
GTK_VALUE_BOOL (*arg) = (child_info->options & GTK_FILL_X) != 0;
break;
case CHILD_ARG_FILL_Y:
GTK_VALUE_BOOL (*arg) = (child_info->options & GTK_FILL_Y) != 0;
break;
case CHILD_ARG_USE_DEFAULT:
GTK_VALUE_BOOL (*arg) = child_info->use_default;
break;
case CHILD_ARG_BORDER_WIDTH:
GTK_VALUE_UINT (*arg) = child_info->border_width;
break;
case CHILD_ARG_PAD_X:
GTK_VALUE_UINT (*arg) = child_info->pad_x;
break;
case CHILD_ARG_PAD_Y:
GTK_VALUE_UINT (*arg) = child_info->pad_y;
break;
case CHILD_ARG_I_PAD_X:
GTK_VALUE_UINT (*arg) = child_info->i_pad_x;
break;
case CHILD_ARG_I_PAD_Y:
GTK_VALUE_UINT (*arg) = child_info->i_pad_y;
break;
case CHILD_ARG_POSITION:
GTK_VALUE_INT (*arg) = 0;
for (list = packer->children; list; list = list->next)
{
child_info = list->data;
if (child_info->widget == child)
break;
GTK_VALUE_INT (*arg)++;
}
if (!list)
GTK_VALUE_INT (*arg) = -1;
break;
default:
arg->type = GTK_TYPE_INVALID;
break;
}
}
static void
gtk_packer_init (GtkPacker *packer)
{
GTK_WIDGET_SET_FLAGS (packer, GTK_NO_WINDOW);
packer->children = NULL;
packer->spacing = 0;
}
void
gtk_packer_set_spacing (GtkPacker *packer,
guint spacing)
{
g_return_if_fail (GTK_IS_PACKER (packer));
if (spacing != packer->spacing)
{
packer->spacing = spacing;
gtk_widget_queue_resize (GTK_WIDGET (packer));
g_object_notify (G_OBJECT (packer), "spacing");
}
}
GtkWidget*
gtk_packer_new (void)
{
return GTK_WIDGET (gtk_type_new (GTK_TYPE_PACKER));
}
static void
redo_defaults_children (GtkPacker *packer)
{
GList *list;
GtkPackerChild *child;
list = g_list_first(packer->children);
while (list != NULL)
{
child = list->data;
if (child->use_default)
{
child->border_width = packer->default_border_width;
child->pad_x = packer->default_pad_x;
child->pad_y = packer->default_pad_y;
child->i_pad_x = packer->default_i_pad_x;
child->i_pad_y = packer->default_i_pad_y;
gtk_widget_queue_resize (GTK_WIDGET (child->widget));
}
list = g_list_next(list);
}
}
void
gtk_packer_set_default_border_width (GtkPacker *packer,
guint border)
{
g_return_if_fail (GTK_IS_PACKER (packer));
if (packer->default_border_width != border)
{
packer->default_border_width = border;;
redo_defaults_children (packer);
g_object_notify (G_OBJECT (packer), "default_border_width");
}
}
void
gtk_packer_set_default_pad (GtkPacker *packer,
guint pad_x,
guint pad_y)
{
g_return_if_fail (GTK_IS_PACKER (packer));
if (packer->default_pad_x != pad_x ||
packer->default_pad_y != pad_y)
{
packer->default_pad_x = pad_x;
packer->default_pad_y = pad_y;
redo_defaults_children (packer);
g_object_freeze_notify (G_OBJECT (packer));
if (packer->default_pad_x != pad_x)
g_object_notify (G_OBJECT (packer), "default_pad_x");
if (packer->default_pad_y != pad_y)
g_object_notify (G_OBJECT (packer), "default_pad_y");
g_object_thaw_notify (G_OBJECT (packer));
}
}
void
gtk_packer_set_default_ipad (GtkPacker *packer,
guint i_pad_x,
guint i_pad_y)
{
g_return_if_fail (GTK_IS_PACKER (packer));
if (packer->default_i_pad_x != i_pad_x ||
packer->default_i_pad_y != i_pad_y) {
packer->default_i_pad_x = i_pad_x;
packer->default_i_pad_y = i_pad_y;
redo_defaults_children (packer);
g_object_freeze_notify (G_OBJECT (packer));
if (packer->default_i_pad_x != i_pad_x)
g_object_notify (G_OBJECT (packer), "default_ipad_x");
if (packer->default_i_pad_y != i_pad_y)
g_object_notify (G_OBJECT (packer), "default_ipad_y");
g_object_thaw_notify (G_OBJECT (packer));
}
}
static void
gtk_packer_container_add (GtkContainer *packer, GtkWidget *child)
{
gtk_packer_add_defaults(GTK_PACKER(packer), child,
GTK_SIDE_TOP, GTK_ANCHOR_CENTER, 0);
}
void
gtk_packer_add_defaults (GtkPacker *packer,
GtkWidget *child,
GtkSideType side,
GtkAnchorType anchor,
GtkPackerOptions options)
{
GtkPackerChild *pchild;
g_return_if_fail (GTK_IS_PACKER (packer));
g_return_if_fail (GTK_IS_WIDGET (child));
pchild = (GtkPackerChild*) g_malloc(sizeof(GtkPackerChild));
pchild->widget = child;
pchild->side = side;
pchild->options = options;
pchild->anchor = anchor;
pchild->use_default = 1;
pchild->border_width = packer->default_border_width;
pchild->pad_x = packer->default_pad_x;
pchild->pad_y = packer->default_pad_y;
pchild->i_pad_x = packer->default_i_pad_x;
pchild->i_pad_y = packer->default_i_pad_y;
packer->children = g_list_append(packer->children, (gpointer) pchild);
gtk_widget_set_parent (child, GTK_WIDGET (packer));
}
void
gtk_packer_add (GtkPacker *packer,
GtkWidget *child,
GtkSideType side,
GtkAnchorType anchor,
GtkPackerOptions options,
guint border_width,
guint pad_x,
guint pad_y,
guint i_pad_x,
guint i_pad_y)
{
GtkPackerChild *pchild;
g_return_if_fail (GTK_IS_PACKER (packer));
g_return_if_fail (GTK_IS_WIDGET (child));
pchild = (GtkPackerChild*) g_malloc(sizeof(GtkPackerChild));
pchild->widget = child;
pchild->side = side;
pchild->options = options;
pchild->anchor = anchor;
pchild->use_default = 0;
pchild->border_width = border_width;
pchild->pad_x = pad_x;
pchild->pad_y = pad_y;
pchild->i_pad_x = i_pad_x;
pchild->i_pad_y = i_pad_y;
packer->children = g_list_append(packer->children, (gpointer) pchild);
gtk_widget_set_parent (child, GTK_WIDGET (packer));
}
void
gtk_packer_set_child_packing (GtkPacker *packer,
GtkWidget *child,
GtkSideType side,
GtkAnchorType anchor,
GtkPackerOptions options,
guint border_width,
guint pad_x,
guint pad_y,
guint i_pad_x,
guint i_pad_y)
{
GList *list;
GtkPackerChild *pchild;
g_return_if_fail (GTK_IS_PACKER (packer));
g_return_if_fail (child != NULL);
list = g_list_first(packer->children);
while (list != NULL)
{
pchild = (GtkPackerChild*) list->data;
if (pchild->widget == child)
{
pchild->side = side;
pchild->anchor = anchor;
pchild->options = options;
pchild->use_default = 0;
pchild->border_width = border_width;
pchild->pad_x = pad_x;
pchild->pad_y = pad_y;
pchild->i_pad_x = i_pad_x;
pchild->i_pad_y = i_pad_y;
if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (packer))
gtk_widget_queue_resize (child);
return;
}
list = g_list_next(list);
}
g_warning ("couldn't find child `%s' amongst the packer's children", gtk_type_name (GTK_OBJECT_TYPE (child)));
}
void
gtk_packer_reorder_child (GtkPacker *packer,
GtkWidget *child,
gint position)
{
GList *list;
g_return_if_fail (GTK_IS_PACKER (packer));
g_return_if_fail (child != NULL);
list = packer->children;
while (list)
{
GtkPackerChild *child_info;
child_info = list->data;
if (child_info->widget == child)
break;
list = list->next;
}
if (list && packer->children->next)
{
GList *tmp_list;
if (list->next)
list->next->prev = list->prev;
if (list->prev)
list->prev->next = list->next;
else
packer->children = list->next;
tmp_list = packer->children;
while (position && tmp_list->next)
{
position--;
tmp_list = tmp_list->next;
}
if (position)
{
tmp_list->next = list;
list->prev = tmp_list;
list->next = NULL;
}
else
{
if (tmp_list->prev)
tmp_list->prev->next = list;
else
packer->children = list;
list->prev = tmp_list->prev;
tmp_list->prev = list;
list->next = tmp_list;
}
if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (packer))
gtk_widget_queue_resize (child);
}
}
static void
gtk_packer_remove (GtkContainer *container,
GtkWidget *widget)
{
GtkPacker *packer;
GtkPackerChild *child;
GList *children;
gint visible;
g_return_if_fail (container != NULL);
g_return_if_fail (widget != NULL);
packer = GTK_PACKER (container);
children = g_list_first(packer->children);
while (children)
{
child = children->data;
if (child->widget == widget)
{
visible = GTK_WIDGET_VISIBLE (widget);
gtk_widget_unparent (widget);
packer->children = g_list_remove_link (packer->children, children);
g_list_free (children);
g_free (child);
if (visible && GTK_WIDGET_VISIBLE (container))
gtk_widget_queue_resize (GTK_WIDGET (container));
break;
}
children = g_list_next(children);
}
}
static void
gtk_packer_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
GtkPacker *packer;
GtkContainer *container;
GtkPackerChild *child;
GList *children;
gint nvis_vert_children;
gint nvis_horz_children;
gint width, height;
gint maxWidth, maxHeight;
g_return_if_fail (GTK_IS_PACKER (widget));
g_return_if_fail (requisition != NULL);
packer = GTK_PACKER (widget);
container = GTK_CONTAINER (widget);
requisition->width = 0;
requisition->height = 0;
nvis_vert_children = 0;
nvis_horz_children = 0;
width = height = maxWidth = maxHeight = 0;
children = g_list_first(packer->children);
while (children != NULL)
{
child = children->data;
if (GTK_WIDGET_VISIBLE (child->widget))
{
GtkRequisition child_requisition;
gtk_widget_size_request (child->widget, &child_requisition);
if ((child->side == GTK_SIDE_TOP) || (child->side == GTK_SIDE_BOTTOM))
{
maxWidth = MAX (maxWidth,
(child_requisition.width +
2 * child->border_width +
child->pad_x + child->i_pad_x +
width));
height += (child_requisition.height +
2 * child->border_width +
child->pad_y + child->i_pad_y);
}
else
{
maxHeight = MAX (maxHeight,
(child_requisition.height +
2 * child->border_width +
child->pad_y + child->i_pad_y +
height));
width += (child_requisition.width +
2 * child->border_width +
child->pad_x + child->i_pad_x);
}
}
children = g_list_next(children);
}
requisition->width = MAX (maxWidth, width) + 2 * container->border_width;
requisition->height = MAX (maxHeight, height) + 2 * container->border_width;
}
static gint
YExpansion (GList *children,
gint cavityHeight)
{
GList *list;
GtkPackerChild *child;
GtkWidget *widget;
gint numExpand, minExpand, curExpand;
gint childHeight;
minExpand = cavityHeight;
numExpand = 0;
list = children;
while (list != NULL)
{
GtkRequisition child_requisition;
child = list->data;
widget = child->widget;
gtk_widget_get_child_requisition (widget, &child_requisition);
childHeight = (child_requisition.height +
2 * child->border_width +
child->i_pad_y +
child->pad_y);
if ((child->side == GTK_SIDE_LEFT) || (child->side == GTK_SIDE_RIGHT))
{
curExpand = (cavityHeight - childHeight)/numExpand;
minExpand = MIN(minExpand, curExpand);
}
else
{
cavityHeight -= childHeight;
if (child->options & GTK_PACK_EXPAND)
numExpand++;
}
list = g_list_next(list);
}
curExpand = cavityHeight/numExpand;
if (curExpand < minExpand)
minExpand = curExpand;
return (minExpand < 0) ? 0 : minExpand;
}
static gint
XExpansion (GList *children,
gint cavityWidth)
{
GList *list;
GtkPackerChild *child;
GtkWidget *widget;
gint numExpand, minExpand, curExpand;
gint childWidth;
minExpand = cavityWidth;
numExpand = 0;
list = children;
while (list != NULL)
{
GtkRequisition child_requisition;
child = list->data;
widget = child->widget;
gtk_widget_get_child_requisition (widget, &child_requisition);
childWidth = (child_requisition.width +
2 * child->border_width +
child->i_pad_x +
child->pad_x);
if ((child->side == GTK_SIDE_TOP) || (child->side == GTK_SIDE_BOTTOM))
{
curExpand = (cavityWidth - childWidth)/numExpand;
minExpand = MIN(minExpand, curExpand);
}
else
{
cavityWidth -= childWidth;
if (child->options & GTK_PACK_EXPAND)
numExpand++;
}
list = g_list_next(list);
}
curExpand = cavityWidth/numExpand;
if (curExpand < minExpand)
minExpand = curExpand;
return (minExpand < 0) ? 0 : minExpand;
}
static void
gtk_packer_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkPacker *packer;
GtkContainer *container;
GtkAllocation child_allocation;
GList *list;
GtkPackerChild *child;
gint cavityX, cavityY;
gint cavityWidth, cavityHeight;
gint width, height, x, y;
gint frameHeight, frameWidth, frameX, frameY;
gint borderX, borderY;
g_return_if_fail (GTK_IS_PACKER (widget));
g_return_if_fail (allocation != NULL);
packer = GTK_PACKER (widget);
container = GTK_CONTAINER (widget);
x = y = 0;
widget->allocation = *allocation;
cavityX = widget->allocation.x + container->border_width;
cavityY = widget->allocation.y + container->border_width;
cavityWidth = widget->allocation.width - 2 * container->border_width;
cavityHeight = widget->allocation.height - 2 * container->border_width;
list = g_list_first (packer->children);
while (list != NULL)
{
GtkRequisition child_requisition;
child = list->data;
gtk_widget_get_child_requisition (child->widget, &child_requisition);
if ((child->side == GTK_SIDE_TOP) || (child->side == GTK_SIDE_BOTTOM))
{
frameWidth = cavityWidth;
frameHeight = (child_requisition.height +
2 * child->border_width +
child->pad_y +
child->i_pad_y);
if (child->options & GTK_PACK_EXPAND)
frameHeight += YExpansion(list, cavityHeight);
cavityHeight -= frameHeight;
if (cavityHeight < 0)
{
frameHeight += cavityHeight;
cavityHeight = 0;
}
frameX = cavityX;
if (child->side == GTK_SIDE_TOP)
{
frameY = cavityY;
cavityY += frameHeight;
}
else
{
frameY = cavityY + cavityHeight;
}
}
else
{
frameHeight = cavityHeight;
frameWidth = (child_requisition.width +
2 * child->border_width +
child->pad_x +
child->i_pad_x);
if (child->options & GTK_PACK_EXPAND)
frameWidth += XExpansion(list, cavityWidth);
cavityWidth -= frameWidth;
if (cavityWidth < 0) {
frameWidth += cavityWidth;
cavityWidth = 0;
}
frameY = cavityY;
if (child->side == GTK_SIDE_LEFT)
{
frameX = cavityX;
cavityX += frameWidth;
}
else
{
frameX = cavityX + cavityWidth;
}
}
borderX = child->pad_x + 2 * child->border_width;
borderY = child->pad_y + 2 * child->border_width;
width = (child_requisition.width +
2 * child->border_width +
child->i_pad_x);
if ((child->options & GTK_FILL_X) || (width > (frameWidth - borderX)))
width = frameWidth - borderX;
height = (child_requisition.height +
2 * child->border_width +
child->i_pad_y);
if ((child->options & GTK_FILL_Y) || (height > (frameHeight - borderY)))
height = frameHeight - borderY;
borderX /= 2;
borderY /= 2;
switch (child->anchor)
{
case GTK_ANCHOR_N:
x = frameX + (frameWidth - width)/2;
y = frameY + borderY;
break;
case GTK_ANCHOR_NE:
x = frameX + frameWidth - width - borderX;
y = frameY + borderY;
break;
case GTK_ANCHOR_E:
x = frameX + frameWidth - width - borderX;
y = frameY + (frameHeight - height)/2;
break;
case GTK_ANCHOR_SE:
x = frameX + frameWidth - width - borderX;
y = frameY + frameHeight - height - borderY;
break;
case GTK_ANCHOR_S:
x = frameX + (frameWidth - width)/2;
y = frameY + frameHeight - height - borderY;
break;
case GTK_ANCHOR_SW:
x = frameX + borderX;
y = frameY + frameHeight - height - borderY;
break;
case GTK_ANCHOR_W:
x = frameX + borderX;
y = frameY + (frameHeight - height)/2;
break;
case GTK_ANCHOR_NW:
x = frameX + borderX;
y = frameY + borderY;
break;
case GTK_ANCHOR_CENTER:
x = frameX + (frameWidth - width)/2;
y = frameY + (frameHeight - height)/2;
break;
default:
g_warning ("gtk_packer_size_allocate(): bad anchor type: %d", child->anchor);
}
if (width <= 0 || height <= 0)
{
gtk_widget_set_child_visible (child->widget, FALSE);
}
else
{
child_allocation.x = x;
child_allocation.y = y;
child_allocation.width = width;
child_allocation.height = height;
gtk_widget_size_allocate (child->widget, &child_allocation);
gtk_widget_set_child_visible (child->widget, TRUE);
}
list = g_list_next(list);
}
}
static void
gtk_packer_forall (GtkContainer *container,
gboolean include_internals,
GtkCallback callback,
gpointer callback_data)
{
GtkPacker *packer;
GtkPackerChild *child;
GList *children;
g_return_if_fail (GTK_IS_PACKER (container));
g_return_if_fail (callback != NULL);
packer = GTK_PACKER (container);
children = g_list_first (packer->children);
while (children != NULL)
{
child = children->data;
children = g_list_next(children);
(* callback) (child->widget, callback_data);
}
}
Reference in New Issue View Git Blame Copy Permalink