ardour/livetrax
13
0
Fork 0
Code
144fe5b08a
livetrax/libs/tk/ytk/gtkaspectframe.c
Robin Gareus ad51c7c2ba
Localize stripped down gtk2 
This is intended mainly for GNU/Linux distros who will remove
GTK2 support in the near future.
2024-01-06 21:52:48 +01:00

356 lines
12 KiB
C
Raw Blame History

/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* GtkAspectFrame: Ensure that the child window has a specified aspect ratio
* or, if obey_child, has the same aspect ratio as its requested size
*
* Copyright Owen Taylor 4/9/97
*
* 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.
*/
/*
* Modified by the GTK+ Team and others 1997-2001. 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/.
*/
/**
* SECTION:gtkaspectframe
* @Short_description: A frame that constrains its child to a particular aspect ratio
* @Title: GtkAspectFrame
*
* The #GtkAspectFrame is useful when you want
* pack a widget so that it can resize but always retains
* the same aspect ratio. For instance, one might be
* drawing a small preview of a larger image. #GtkAspectFrame
* derives from #GtkFrame, so it can draw a label and
* a frame around the child. The frame will be
* "shrink-wrapped" to the size of the child.
*/
#include "config.h"
#include "gtkaspectframe.h"
#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
enum {
PROP_0,
PROP_XALIGN,
PROP_YALIGN,
PROP_RATIO,
PROP_OBEY_CHILD
};
static void gtk_aspect_frame_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gtk_aspect_frame_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void gtk_aspect_frame_compute_child_allocation (GtkFrame *frame,
GtkAllocation *child_allocation);
#define MAX_RATIO 10000.0
#define MIN_RATIO 0.0001
G_DEFINE_TYPE (GtkAspectFrame, gtk_aspect_frame, GTK_TYPE_FRAME)
static void
gtk_aspect_frame_class_init (GtkAspectFrameClass *class)
{
GObjectClass *gobject_class;
GtkFrameClass *frame_class;
gobject_class = (GObjectClass*) class;
frame_class = (GtkFrameClass*) class;
gobject_class->set_property = gtk_aspect_frame_set_property;
gobject_class->get_property = gtk_aspect_frame_get_property;
frame_class->compute_child_allocation = gtk_aspect_frame_compute_child_allocation;
g_object_class_install_property (gobject_class,
PROP_XALIGN,
g_param_spec_float ("xalign",
P_("Horizontal Alignment"),
P_("X alignment of the child"),
0.0, 1.0, 0.5,
GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_YALIGN,
g_param_spec_float ("yalign",
P_("Vertical Alignment"),
P_("Y alignment of the child"),
0.0, 1.0, 0.5,
GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_RATIO,
g_param_spec_float ("ratio",
P_("Ratio"),
P_("Aspect ratio if obey_child is FALSE"),
MIN_RATIO, MAX_RATIO, 1.0,
GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_OBEY_CHILD,
g_param_spec_boolean ("obey-child",
P_("Obey child"),
P_("Force aspect ratio to match that of the frame's child"),
TRUE,
GTK_PARAM_READWRITE));
}
static void
gtk_aspect_frame_init (GtkAspectFrame *aspect_frame)
{
aspect_frame->xalign = 0.5;
aspect_frame->yalign = 0.5;
aspect_frame->ratio = 1.0;
aspect_frame->obey_child = TRUE;
}
static void
gtk_aspect_frame_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkAspectFrame *aspect_frame = GTK_ASPECT_FRAME (object);
switch (prop_id)
{
/* g_object_notify is handled by the _frame_set function */
case PROP_XALIGN:
gtk_aspect_frame_set (aspect_frame,
g_value_get_float (value),
aspect_frame->yalign,
aspect_frame->ratio,
aspect_frame->obey_child);
break;
case PROP_YALIGN:
gtk_aspect_frame_set (aspect_frame,
aspect_frame->xalign,
g_value_get_float (value),
aspect_frame->ratio,
aspect_frame->obey_child);
break;
case PROP_RATIO:
gtk_aspect_frame_set (aspect_frame,
aspect_frame->xalign,
aspect_frame->yalign,
g_value_get_float (value),
aspect_frame->obey_child);
break;
case PROP_OBEY_CHILD:
gtk_aspect_frame_set (aspect_frame,
aspect_frame->xalign,
aspect_frame->yalign,
aspect_frame->ratio,
g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_aspect_frame_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkAspectFrame *aspect_frame = GTK_ASPECT_FRAME (object);
switch (prop_id)
{
case PROP_XALIGN:
g_value_set_float (value, aspect_frame->xalign);
break;
case PROP_YALIGN:
g_value_set_float (value, aspect_frame->yalign);
break;
case PROP_RATIO:
g_value_set_float (value, aspect_frame->ratio);
break;
case PROP_OBEY_CHILD:
g_value_set_boolean (value, aspect_frame->obey_child);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/**
* gtk_aspect_frame_new:
* @label: Label text.
* @xalign: Horizontal alignment of the child within the allocation of
* the #GtkAspectFrame. This ranges from 0.0 (left aligned)
* to 1.0 (right aligned)
* @yalign: Vertical alignment of the child within the allocation of
* the #GtkAspectFrame. This ranges from 0.0 (left aligned)
* to 1.0 (right aligned)
* @ratio: The desired aspect ratio.
* @obey_child: If %TRUE, @ratio is ignored, and the aspect
* ratio is taken from the requistion of the child.
*
* Create a new #GtkAspectFrame.
*
* Returns: the new #GtkAspectFrame.
*/
GtkWidget*
gtk_aspect_frame_new (const gchar *label,
gfloat xalign,
gfloat yalign,
gfloat ratio,
gboolean obey_child)
{
GtkAspectFrame *aspect_frame;
aspect_frame = g_object_new (GTK_TYPE_ASPECT_FRAME, NULL);
aspect_frame->xalign = CLAMP (xalign, 0.0, 1.0);
aspect_frame->yalign = CLAMP (yalign, 0.0, 1.0);
aspect_frame->ratio = CLAMP (ratio, MIN_RATIO, MAX_RATIO);
aspect_frame->obey_child = obey_child != FALSE;
gtk_frame_set_label (GTK_FRAME(aspect_frame), label);
return GTK_WIDGET (aspect_frame);
}
/**
* gtk_aspect_frame_set:
* @aspect_frame: a #GtkAspectFrame
* @xalign: Horizontal alignment of the child within the allocation of
* the #GtkAspectFrame. This ranges from 0.0 (left aligned)
* to 1.0 (right aligned)
* @yalign: Vertical alignment of the child within the allocation of
* the #GtkAspectFrame. This ranges from 0.0 (left aligned)
* to 1.0 (right aligned)
* @ratio: The desired aspect ratio.
* @obey_child: If %TRUE, @ratio is ignored, and the aspect
* ratio is taken from the requistion of the child.
*
* Set parameters for an existing #GtkAspectFrame.
*/
void
gtk_aspect_frame_set (GtkAspectFrame *aspect_frame,
gfloat xalign,
gfloat yalign,
gfloat ratio,
gboolean obey_child)
{
g_return_if_fail (GTK_IS_ASPECT_FRAME (aspect_frame));
xalign = CLAMP (xalign, 0.0, 1.0);
yalign = CLAMP (yalign, 0.0, 1.0);
ratio = CLAMP (ratio, MIN_RATIO, MAX_RATIO);
obey_child = obey_child != FALSE;
if ( (aspect_frame->xalign != xalign)
|| (aspect_frame->yalign != yalign)
|| (aspect_frame->ratio != ratio)
|| (aspect_frame->obey_child != obey_child))
{
g_object_freeze_notify (G_OBJECT (aspect_frame));
if (aspect_frame->xalign != xalign)
{
aspect_frame->xalign = xalign;
g_object_notify (G_OBJECT (aspect_frame), "xalign");
}
if (aspect_frame->yalign != yalign)
{
aspect_frame->yalign = yalign;
g_object_notify (G_OBJECT (aspect_frame), "yalign");
}
if (aspect_frame->ratio != ratio)
{
aspect_frame->ratio = ratio;
g_object_notify (G_OBJECT (aspect_frame), "ratio");
}
if (aspect_frame->obey_child != obey_child)
{
aspect_frame->obey_child = obey_child;
g_object_notify (G_OBJECT (aspect_frame), "obey-child");
}
g_object_thaw_notify (G_OBJECT (aspect_frame));
gtk_widget_queue_resize (GTK_WIDGET (aspect_frame));
}
}
static void
gtk_aspect_frame_compute_child_allocation (GtkFrame *frame,
GtkAllocation *child_allocation)
{
GtkAspectFrame *aspect_frame = GTK_ASPECT_FRAME (frame);
GtkBin *bin = GTK_BIN (frame);
gdouble ratio;
if (bin->child && gtk_widget_get_visible (bin->child))
{
GtkAllocation full_allocation;
if (aspect_frame->obey_child)
{
GtkRequisition child_requisition;
gtk_widget_get_child_requisition (bin->child, &child_requisition);
if (child_requisition.height != 0)
{
ratio = ((gdouble) child_requisition.width /
child_requisition.height);
if (ratio < MIN_RATIO)
ratio = MIN_RATIO;
}
else if (child_requisition.width != 0)
ratio = MAX_RATIO;
else
ratio = 1.0;
}
else
ratio = aspect_frame->ratio;
GTK_FRAME_CLASS (gtk_aspect_frame_parent_class)->compute_child_allocation (frame, &full_allocation);
if (ratio * full_allocation.height > full_allocation.width)
{
child_allocation->width = full_allocation.width;
child_allocation->height = full_allocation.width / ratio + 0.5;
}
else
{
child_allocation->width = ratio * full_allocation.height + 0.5;
child_allocation->height = full_allocation.height;
}
child_allocation->x = full_allocation.x + aspect_frame->xalign * (full_allocation.width - child_allocation->width);
child_allocation->y = full_allocation.y + aspect_frame->yalign * (full_allocation.height - child_allocation->height);
}
else
GTK_FRAME_CLASS (gtk_aspect_frame_parent_class)->compute_child_allocation (frame, child_allocation);
}
#define __GTK_ASPECT_FRAME_C__
#include "gtkaliasdef.c"
View Git Blame Copy Permalink