aboutsummaryrefslogtreecommitdiffstats
path: root/widgets/misc
diff options
context:
space:
mode:
Diffstat (limited to 'widgets/misc')
-rw-r--r--widgets/misc/Makefile.am2
-rw-r--r--widgets/misc/e-scroll-frame.c1215
-rw-r--r--widgets/misc/e-scroll-frame.h95
3 files changed, 1312 insertions, 0 deletions
diff --git a/widgets/misc/Makefile.am b/widgets/misc/Makefile.am
index c3599c98a6..9596668e1f 100644
--- a/widgets/misc/Makefile.am
+++ b/widgets/misc/Makefile.am
@@ -13,6 +13,8 @@ noinst_LIBRARIES = \
libemiscwidgets_a_SOURCES = \
e-clipped-label.c \
e-clipped-label.h \
+ e-scroll-frame.c \
+ e-scroll-frame.h \
e-title-bar.c \
e-title-bar.h
diff --git a/widgets/misc/e-scroll-frame.c b/widgets/misc/e-scroll-frame.c
new file mode 100644
index 0000000000..f36e5a1fbe
--- /dev/null
+++ b/widgets/misc/e-scroll-frame.c
@@ -0,0 +1,1215 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * 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-1999. 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/.
+ */
+
+/* EScrollFrame based on GtkScrolledWindow.
+ *
+ * Modifications by Federico Mena <federico@helixcode.com>
+ */
+
+#include <config.h>
+#include <gtk/gtkhscrollbar.h>
+#include <gtk/gtkvscrollbar.h>
+#include <gtk/gtksignal.h>
+#include <gtk/gtkviewport.h>
+#include "e-scroll-frame.h"
+
+
+/* scrolled window policy and size requisition handling:
+ *
+ * gtk size requisition works as follows:
+ * a widget upon size-request reports the width and height that it finds
+ * to be best suited to display its contents, including children.
+ * the width and/or height reported from a widget upon size requisition
+ * may be overidden by the user by specifying a width and/or height
+ * other than 0 through gtk_widget_set_usize().
+ *
+ * a scrolled window needs (for imlementing all three policy types) to
+ * request its width and height based on two different rationales.
+ * 1) the user wants the scrolled window to just fit into the space
+ * that it gets allocated for a specifc dimension.
+ * 1.1) this does not apply if the user specified a concrete value
+ * value for that specific dimension by either specifying usize for the
+ * scrolled window or for its child.
+ * 2) the user wants the scrolled window to take as much space up as
+ * is desired by the child for a specifc dimension (i.e. POLICY_NEVER).
+ *
+ * also, kinda obvious:
+ * 3) a user would certainly not have choosen a scrolled window as a container
+ * for the child, if the resulting allocation takes up more space than the
+ * child would have allocated without the scrolled window.
+ *
+ * conclusions:
+ * A) from 1) follows: the scrolled window shouldn't request more space for a
+ * specifc dimension than is required at minimum.
+ * B) from 1.1) follows: the requisition may be overidden by usize of the scrolled
+ * window (done automatically) or by usize of the child (needs to be checked).
+ * C) from 2) follows: for POLICY_NEVER, the scrolled window simply reports the
+ * child's dimension.
+ * D) from 3) follows: the scrolled window child's minimum width and minimum height
+ * under A) at least correspond to the space taken up by its scrollbars.
+ */
+
+/* Object argument IDs */
+enum {
+ ARG_0,
+ ARG_HADJUSTMENT,
+ ARG_VADJUSTMENT,
+ ARG_HSCROLLBAR_POLICY,
+ ARG_VSCROLLBAR_POLICY,
+ ARG_FRAME_PLACEMENT,
+ ARG_SHADOW_TYPE,
+ ARG_SCROLLBAR_SPACING
+};
+
+/* Private part of the EScrollFrame structure */
+typedef struct {
+ /* Horizontal and vertical scrollbars */
+ GtkWidget *hsb;
+ GtkWidget *vsb;
+
+ /* Space between scrollbars and frame */
+ guint sb_spacing;
+
+ /* Allocation for frame */
+ guint frame_x;
+ guint frame_y;
+ guint frame_w;
+ guint frame_h;
+
+ /* Scrollbar policy */
+ guint hsb_policy : 2;
+ guint vsb_policy : 2;
+
+ /* Whether scrollbars are visible */
+ guint hsb_visible : 1;
+ guint vsb_visible : 1;
+
+ /* Placement of frame wrt scrollbars */
+ guint frame_placement : 2;
+
+ /* Shadow type for frame */
+ guint shadow_type : 3;
+} ScrollFramePrivate;
+
+
+static void e_scroll_frame_class_init (EScrollFrameClass *class);
+static void e_scroll_frame_init (EScrollFrame *sf);
+static void e_scroll_frame_set_arg (GtkObject *object, GtkArg *arg, guint arg_id);
+static void e_scroll_frame_get_arg (GtkObject *object, GtkArg *arg, guint arg_id);
+static void e_scroll_frame_destroy (GtkObject *object);
+static void e_scroll_frame_finalize (GtkObject *object);
+
+static void e_scroll_frame_map (GtkWidget *widget);
+static void e_scroll_frame_unmap (GtkWidget *widget);
+static void e_scroll_frame_draw (GtkWidget *widget, GdkRectangle *area);
+static void e_scroll_frame_size_request (GtkWidget *widget, GtkRequisition *requisition);
+static void e_scroll_frame_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
+static gint e_scroll_frame_expose (GtkWidget *widget, GdkEventExpose *event);
+
+static void e_scroll_frame_add (GtkContainer *container, GtkWidget *widget);
+static void e_scroll_frame_remove (GtkContainer *container, GtkWidget *widget);
+static void e_scroll_frame_forall (GtkContainer *container, gboolean include_internals,
+ GtkCallback callback, gpointer callback_data);
+
+static GtkBinClass *parent_class;
+
+
+/**
+ * e_scroll_frame_get_type:
+ * @void:
+ *
+ * Registers the #EScrollFrame class if necessary, and returns the type ID
+ * associated to it.
+ *
+ * Return value: The type ID of the #EScrollFrame class.
+ **/
+GtkType
+e_scroll_frame_get_type (void)
+{
+ static GtkType scroll_frame_type = 0;
+
+ if (!scroll_frame_type) {
+ static const GtkTypeInfo scroll_frame_info = {
+ "EScrollFrame",
+ sizeof (EScrollFrame),
+ sizeof (EScrollFrameClass),
+ (GtkClassInitFunc) e_scroll_frame_class_init,
+ (GtkObjectInitFunc) e_scroll_frame_init,
+ NULL, /* reserved_1 */
+ NULL, /* reserved_2 */
+ (GtkClassInitFunc) NULL
+ };
+
+ scroll_frame_type = gtk_type_unique (GTK_TYPE_BIN, &scroll_frame_info);
+ }
+
+ return scroll_frame_type;
+}
+
+/* Class initialization function for the scroll frame widget */
+static void
+e_scroll_frame_class_init (EScrollFrameClass *class)
+{
+ GtkObjectClass *object_class;
+ GtkWidgetClass *widget_class;
+ GtkContainerClass *container_class;
+
+ object_class = (GtkObjectClass *) class;
+ widget_class = (GtkWidgetClass *) class;
+ container_class = (GtkContainerClass *) class;
+
+ parent_class = gtk_type_class (GTK_TYPE_BIN);
+
+ gtk_object_add_arg_type ("EScrollFrame::hadjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_HADJUSTMENT);
+ gtk_object_add_arg_type ("EScrollFrame::vadjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_VADJUSTMENT);
+ gtk_object_add_arg_type ("EScrollFrame::hscrollbar_policy",
+ GTK_TYPE_POLICY_TYPE,
+ GTK_ARG_READWRITE,
+ ARG_HSCROLLBAR_POLICY);
+ gtk_object_add_arg_type ("EScrollFrame::vscrollbar_policy",
+ GTK_TYPE_POLICY_TYPE,
+ GTK_ARG_READWRITE,
+ ARG_VSCROLLBAR_POLICY);
+ gtk_object_add_arg_type ("EScrollFrame::frame_placement",
+ GTK_TYPE_CORNER_TYPE,
+ GTK_ARG_READWRITE,
+ ARG_FRAME_PLACEMENT);
+ gtk_object_add_arg_type ("EScrollFrame::shadow_type",
+ GTK_TYPE_SHADOW_TYPE,
+ GTK_ARG_READWRITE,
+ ARG_SHADOW_TYPE);
+ gtk_object_add_arg_type ("EScrollFrame::scrollbar_spacing",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE,
+ ARG_SCROLLBAR_SPACING);
+
+ object_class->set_arg = e_scroll_frame_set_arg;
+ object_class->get_arg = e_scroll_frame_get_arg;
+ object_class->destroy = e_scroll_frame_destroy;
+ object_class->finalize = e_scroll_frame_finalize;
+
+ widget_class->map = e_scroll_frame_map;
+ widget_class->unmap = e_scroll_frame_unmap;
+ widget_class->draw = e_scroll_frame_draw;
+ widget_class->size_request = e_scroll_frame_size_request;
+ widget_class->size_allocate = e_scroll_frame_size_allocate;
+ widget_class->expose_event = e_scroll_frame_expose;
+
+ container_class->add = e_scroll_frame_add;
+ container_class->remove = e_scroll_frame_remove;
+ container_class->forall = e_scroll_frame_forall;
+}
+
+/* Object initialization function for the scroll frame widget */
+static void
+e_scroll_frame_init (EScrollFrame *sf)
+{
+ ScrollFramePrivate *priv;
+
+ priv = g_new0 (ScrollFramePrivate, 1);
+ sf->priv = priv;
+
+ GTK_WIDGET_SET_FLAGS (sf, GTK_NO_WINDOW);
+
+ gtk_container_set_resize_mode (GTK_CONTAINER (sf), GTK_RESIZE_QUEUE);
+
+ priv->sb_spacing = 3;
+ priv->hsb_policy = GTK_POLICY_ALWAYS;
+ priv->vsb_policy = GTK_POLICY_ALWAYS;
+ priv->frame_placement = GTK_CORNER_TOP_LEFT;
+ priv->shadow_type = GTK_SHADOW_NONE;
+}
+
+/* Set_arg handler for the scroll frame widget */
+static void
+e_scroll_frame_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+
+ sf = E_SCROLL_FRAME (object);
+ priv = sf->priv;
+
+ switch (arg_id) {
+ case ARG_HADJUSTMENT:
+ e_scroll_frame_set_hadjustment (sf, GTK_VALUE_POINTER (*arg));
+ break;
+
+ case ARG_VADJUSTMENT:
+ e_scroll_frame_set_vadjustment (sf, GTK_VALUE_POINTER (*arg));
+ break;
+
+ case ARG_HSCROLLBAR_POLICY:
+ e_scroll_frame_set_policy (sf, GTK_VALUE_ENUM (*arg), priv->vsb_policy);
+ break;
+
+ case ARG_VSCROLLBAR_POLICY:
+ e_scroll_frame_set_policy (sf, priv->hsb_policy, GTK_VALUE_ENUM (*arg));
+ break;
+
+ case ARG_FRAME_PLACEMENT:
+ e_scroll_frame_set_placement (sf, GTK_VALUE_ENUM (*arg));
+ break;
+
+ case ARG_SHADOW_TYPE:
+ e_scroll_frame_set_shadow_type (sf, GTK_VALUE_ENUM (*arg));
+ break;
+
+ case ARG_SCROLLBAR_SPACING:
+ e_scroll_frame_set_scrollbar_spacing (sf, GTK_VALUE_UINT (*arg));
+ break;
+
+ default:
+ break;
+ }
+}
+
+/* Get_arg handler for the scroll frame widget */
+static void
+e_scroll_frame_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+
+ sf = E_SCROLL_FRAME (object);
+ priv = sf->priv;
+
+ switch (arg_id) {
+ case ARG_HADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = e_scroll_frame_get_hadjustment (sf);
+ break;
+
+ case ARG_VADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = e_scroll_frame_get_vadjustment (sf);
+ break;
+
+ case ARG_HSCROLLBAR_POLICY:
+ GTK_VALUE_ENUM (*arg) = priv->hsb_policy;
+ break;
+
+ case ARG_VSCROLLBAR_POLICY:
+ GTK_VALUE_ENUM (*arg) = priv->vsb_policy;
+ break;
+
+ case ARG_FRAME_PLACEMENT:
+ GTK_VALUE_ENUM (*arg) = priv->frame_placement;
+ break;
+
+ case ARG_SHADOW_TYPE:
+ GTK_VALUE_ENUM (*arg) = priv->shadow_type;
+ break;
+
+ case ARG_SCROLLBAR_SPACING:
+ GTK_VALUE_UINT (*arg) = priv->sb_spacing;
+ break;
+
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
+/* Destroy handler for the scroll frame widget */
+static void
+e_scroll_frame_destroy (GtkObject *object)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (object));
+
+ sf = E_SCROLL_FRAME (object);
+ priv = sf->priv;
+
+ gtk_widget_unparent (priv->hsb);
+ gtk_widget_unparent (priv->vsb);
+ gtk_widget_destroy (priv->hsb);
+ gtk_widget_destroy (priv->vsb);
+
+ if (GTK_OBJECT_CLASS (parent_class)->destroy)
+ (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+}
+
+/* Finalize handler for the scroll frame widget */
+static void
+e_scroll_frame_finalize (GtkObject *object)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+
+ sf = E_SCROLL_FRAME (object);
+ priv = sf->priv;
+
+ gtk_widget_unref (priv->hsb);
+ gtk_widget_unref (priv->vsb);
+
+ g_free (priv);
+
+ if (GTK_OBJECT_CLASS (parent_class)->finalize)
+ (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+}
+
+/* Map handler for the scroll frame widget */
+static void
+e_scroll_frame_map (GtkWidget *widget)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (widget));
+
+ sf = E_SCROLL_FRAME (widget);
+ priv = sf->priv;
+
+ /* chain parent class handler to map self and child */
+ if (GTK_WIDGET_CLASS (parent_class)->map)
+ (* GTK_WIDGET_CLASS (parent_class)->map) (widget);
+
+ if (GTK_WIDGET_VISIBLE (priv->hsb) && !GTK_WIDGET_MAPPED (priv->hsb))
+ gtk_widget_map (priv->hsb);
+
+ if (GTK_WIDGET_VISIBLE (priv->vsb) && !GTK_WIDGET_MAPPED (priv->vsb))
+ gtk_widget_map (priv->vsb);
+}
+
+/* Unmap handler for the scroll frame widget */
+static void
+e_scroll_frame_unmap (GtkWidget *widget)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (widget));
+
+ sf = E_SCROLL_FRAME (widget);
+ priv = sf->priv;
+
+ /* chain parent class handler to unmap self and child */
+ if (GTK_WIDGET_CLASS (parent_class)->unmap)
+ (* GTK_WIDGET_CLASS (parent_class)->unmap) (widget);
+
+ if (GTK_WIDGET_MAPPED (priv->hsb))
+ gtk_widget_unmap (priv->hsb);
+
+ if (GTK_WIDGET_MAPPED (priv->vsb))
+ gtk_widget_unmap (priv->vsb);
+}
+
+/* Draws the shadow of a scroll frame widget */
+static void
+draw_shadow (EScrollFrame *sf, GdkRectangle *area)
+{
+ ScrollFramePrivate *priv;
+
+ g_assert (area != NULL);
+
+ priv = sf->priv;
+
+ gtk_paint_shadow (GTK_WIDGET (sf)->style,
+ GTK_WIDGET (sf)->window,
+ GTK_STATE_NORMAL, priv->shadow_type,
+ area, GTK_WIDGET (sf),
+ "scroll_frame",
+ priv->frame_x, priv->frame_y,
+ priv->frame_w, priv->frame_h);
+}
+
+/* Draw handler for the scroll frame widget */
+static void
+e_scroll_frame_draw (GtkWidget *widget, GdkRectangle *area)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+ GtkBin *bin;
+ GdkRectangle child_area;
+
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (widget));
+ g_return_if_fail (area != NULL);
+
+ sf = E_SCROLL_FRAME (widget);
+ priv = sf->priv;
+ bin = GTK_BIN (widget);
+
+ if (GTK_WIDGET_DRAWABLE (widget))
+ draw_shadow (sf, area);
+
+ if (bin->child && GTK_WIDGET_VISIBLE (bin->child)
+ && gtk_widget_intersect (bin->child, area, &child_area))
+ gtk_widget_draw (bin->child, &child_area);
+
+ if (GTK_WIDGET_VISIBLE (priv->hsb)
+ && gtk_widget_intersect (priv->hsb, area, &child_area))
+ gtk_widget_draw (priv->hsb, &child_area);
+
+ if (GTK_WIDGET_VISIBLE (priv->vsb)
+ && gtk_widget_intersect (priv->vsb, area, &child_area))
+ gtk_widget_draw (priv->vsb, &child_area);
+}
+
+/* Forall handler for the scroll frame widget */
+static void
+e_scroll_frame_forall (GtkContainer *container, gboolean include_internals,
+ GtkCallback callback, gpointer callback_data)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+
+ g_return_if_fail (container != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (container));
+ g_return_if_fail (callback != NULL);
+
+ sf = E_SCROLL_FRAME (container);
+ priv = sf->priv;
+
+ if (GTK_CONTAINER_CLASS (parent_class)->forall)
+ (* GTK_CONTAINER_CLASS (parent_class)->forall) (
+ container, include_internals,
+ callback, callback_data);
+
+ if (include_internals) {
+ if (priv->vsb)
+ (* callback) (priv->vsb, callback_data);
+
+ if (priv->hsb)
+ (* callback) (priv->hsb, callback_data);
+ }
+}
+
+/* Size_request handler for the scroll frame widget */
+static void
+e_scroll_frame_size_request (GtkWidget *widget, GtkRequisition *requisition)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+ GtkBin *bin;
+ gint extra_width;
+ gint extra_height;
+ GtkRequisition hsb_requisition;
+ GtkRequisition vsb_requisition;
+ GtkRequisition child_requisition;
+
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (widget));
+ g_return_if_fail (requisition != NULL);
+
+ sf = E_SCROLL_FRAME (widget);
+ priv = sf->priv;
+ bin = GTK_BIN (widget);
+
+ extra_width = 0;
+ extra_height = 0;
+
+ requisition->width = GTK_CONTAINER (widget)->border_width * 2;
+ requisition->height = GTK_CONTAINER (widget)->border_width * 2;
+
+ if (priv->shadow_type != GTK_SHADOW_NONE) {
+ requisition->width += 2 * widget->style->klass->xthickness;
+ requisition->height += 2 * widget->style->klass->ythickness;
+ }
+
+ gtk_widget_size_request (priv->hsb, &hsb_requisition);
+ gtk_widget_size_request (priv->vsb, &vsb_requisition);
+
+ if (bin->child && GTK_WIDGET_VISIBLE (bin->child)) {
+ static guint quark_aux_info;
+
+ if (!quark_aux_info)
+ quark_aux_info = g_quark_from_static_string ("gtk-aux-info");
+
+ gtk_widget_size_request (bin->child, &child_requisition);
+
+ if (priv->hsb_policy == GTK_POLICY_NEVER)
+ requisition->width += child_requisition.width;
+ else {
+ GtkWidgetAuxInfo *aux_info;
+
+ aux_info = gtk_object_get_data_by_id (GTK_OBJECT (bin->child),
+ quark_aux_info);
+ if (aux_info && aux_info->width > 0) {
+ requisition->width += aux_info->width;
+ extra_width = -1;
+ } else
+ requisition->width += vsb_requisition.width;
+ }
+
+ if (priv->vsb_policy == GTK_POLICY_NEVER)
+ requisition->height += child_requisition.height;
+ else {
+ GtkWidgetAuxInfo *aux_info;
+
+ aux_info = gtk_object_get_data_by_id (GTK_OBJECT (bin->child),
+ quark_aux_info);
+ if (aux_info && aux_info->height > 0) {
+ requisition->height += aux_info->height;
+ extra_height = -1;
+ } else
+ requisition->height += hsb_requisition.height;
+ }
+ }
+
+ if (priv->hsb_policy == GTK_POLICY_AUTOMATIC || GTK_WIDGET_VISIBLE (priv->hsb)) {
+ requisition->width = MAX (requisition->width, hsb_requisition.width);
+ if (!extra_height || GTK_WIDGET_VISIBLE (priv->hsb))
+ extra_height = priv->sb_spacing + hsb_requisition.height;
+ }
+
+ if (priv->vsb_policy == GTK_POLICY_AUTOMATIC || GTK_WIDGET_VISIBLE (priv->vsb)) {
+ requisition->height = MAX (requisition->height, vsb_requisition.height);
+ if (!extra_width || GTK_WIDGET_VISIBLE (priv->vsb))
+ extra_width = priv->sb_spacing + vsb_requisition.width;
+ }
+
+ requisition->width += MAX (0, extra_width);
+ requisition->height += MAX (0, extra_height);
+}
+
+/* Computes the relative allocation for the scroll frame widget */
+static void
+compute_relative_allocation (GtkWidget *widget, GtkAllocation *allocation)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+
+ g_assert (widget != NULL);
+ g_assert (E_IS_SCROLL_FRAME (widget));
+ g_assert (allocation != NULL);
+
+ sf = E_SCROLL_FRAME (widget);
+ priv = sf->priv;
+
+ allocation->x = GTK_CONTAINER (widget)->border_width;
+ allocation->y = GTK_CONTAINER (widget)->border_width;
+ allocation->width = MAX (1, (gint) widget->allocation.width - allocation->x * 2);
+ allocation->height = MAX (1, (gint) widget->allocation.height - allocation->y * 2);
+
+ if (priv->vsb_visible) {
+ GtkRequisition vsb_requisition;
+
+ gtk_widget_get_child_requisition (priv->vsb, &vsb_requisition);
+
+ if (priv->frame_placement == GTK_CORNER_TOP_RIGHT
+ || priv->frame_placement == GTK_CORNER_BOTTOM_RIGHT)
+ allocation->x += vsb_requisition.width + priv->sb_spacing;
+
+ allocation->width = MAX (1, ((gint) allocation->width
+ - ((gint) vsb_requisition.width + priv->sb_spacing)));
+ }
+
+ if (priv->hsb_visible) {
+ GtkRequisition hsb_requisition;
+
+ gtk_widget_get_child_requisition (priv->hsb, &hsb_requisition);
+
+ if (priv->frame_placement == GTK_CORNER_BOTTOM_LEFT
+ || priv->frame_placement == GTK_CORNER_BOTTOM_RIGHT)
+ allocation->y += hsb_requisition.height + priv->sb_spacing;
+
+ allocation->height = MAX (1, ((gint) allocation->height
+ - ((gint) hsb_requisition.height + priv->sb_spacing)));
+ }
+}
+
+/* Size_allocate handler for the scroll frame widget */
+static void
+e_scroll_frame_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+ GtkBin *bin;
+ GtkAllocation relative_allocation;
+ GtkAllocation child_allocation;
+ gint xthickness, ythickness;
+
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (widget));
+ g_return_if_fail (allocation != NULL);
+
+ sf = E_SCROLL_FRAME (widget);
+ priv = sf->priv;
+ bin = GTK_BIN (widget);
+
+ widget->allocation = *allocation;
+
+ if (priv->hsb_policy == GTK_POLICY_ALWAYS)
+ priv->hsb_visible = TRUE;
+ else if (priv->hsb_policy == GTK_POLICY_NEVER)
+ priv->hsb_visible = FALSE;
+
+ if (priv->vsb_policy == GTK_POLICY_ALWAYS)
+ priv->vsb_visible = TRUE;
+ else if (priv->vsb_policy == GTK_POLICY_NEVER)
+ priv->vsb_visible = FALSE;
+
+ if (priv->shadow_type == GTK_SHADOW_NONE) {
+ xthickness = 0;
+ ythickness = 0;
+ } else {
+ xthickness = widget->style->klass->xthickness;
+ ythickness = widget->style->klass->ythickness;
+ }
+
+ if (bin->child && GTK_WIDGET_VISIBLE (bin->child)) {
+ gboolean previous_hvis;
+ gboolean previous_vvis;
+ guint count = 0;
+
+ do {
+ compute_relative_allocation (widget, &relative_allocation);
+
+ priv->frame_x = relative_allocation.x + allocation->x;
+ priv->frame_y = relative_allocation.y + allocation->y;
+ priv->frame_w = relative_allocation.width;
+ priv->frame_h = relative_allocation.height;
+
+ child_allocation.x = priv->frame_x + xthickness;
+ child_allocation.y = priv->frame_y + ythickness;
+ child_allocation.width = priv->frame_w - 2 * xthickness;
+ child_allocation.height = priv->frame_h - 2 * ythickness;
+
+ previous_hvis = priv->hsb_visible;
+ previous_vvis = priv->vsb_visible;
+
+ gtk_widget_size_allocate (bin->child, &child_allocation);
+
+ /* If, after the first iteration, the hscrollbar and the
+ * vscrollbar flip visiblity, then we need both.
+ */
+ if (count
+ && previous_hvis != priv->hsb_visible
+ && previous_vvis != priv->vsb_visible) {
+ priv->hsb_visible = TRUE;
+ priv->vsb_visible = TRUE;
+
+ /* a new resize is already queued at this point,
+ * so we will immediatedly get reinvoked
+ */
+ return;
+ }
+
+ count++;
+ } while (previous_hvis != priv->hsb_visible
+ || previous_vvis != priv->vsb_visible);
+ } else
+ compute_relative_allocation (widget, &relative_allocation);
+
+ if (priv->hsb_visible) {
+ GtkRequisition hscrollbar_requisition;
+
+ gtk_widget_get_child_requisition (priv->hsb, &hscrollbar_requisition);
+
+ if (!GTK_WIDGET_VISIBLE (priv->hsb))
+ gtk_widget_show (priv->hsb);
+
+ child_allocation.x = relative_allocation.x;
+ if (priv->frame_placement == GTK_CORNER_TOP_LEFT
+ || priv->frame_placement == GTK_CORNER_TOP_RIGHT)
+ child_allocation.y = (relative_allocation.y
+ + relative_allocation.height
+ + priv->sb_spacing);
+ else
+ child_allocation.y = GTK_CONTAINER (sf)->border_width;
+
+ child_allocation.width = relative_allocation.width;
+ child_allocation.height = hscrollbar_requisition.height;
+ child_allocation.x += allocation->x;
+ child_allocation.y += allocation->y;
+
+ gtk_widget_size_allocate (priv->hsb, &child_allocation);
+ } else if (GTK_WIDGET_VISIBLE (priv->hsb))
+ gtk_widget_hide (priv->hsb);
+
+ if (priv->vsb_visible) {
+ GtkRequisition vscrollbar_requisition;
+
+ if (!GTK_WIDGET_VISIBLE (priv->vsb))
+ gtk_widget_show (priv->vsb);
+
+ gtk_widget_get_child_requisition (priv->vsb, &vscrollbar_requisition);
+
+ if (priv->frame_placement == GTK_CORNER_TOP_LEFT
+ || priv->frame_placement == GTK_CORNER_BOTTOM_LEFT)
+ child_allocation.x = (relative_allocation.x
+ + relative_allocation.width
+ + priv->sb_spacing);
+ else
+ child_allocation.x = GTK_CONTAINER (sf)->border_width;
+
+ child_allocation.y = relative_allocation.y;
+ child_allocation.width = vscrollbar_requisition.width;
+ child_allocation.height = relative_allocation.height;
+ child_allocation.x += allocation->x;
+ child_allocation.y += allocation->y;
+
+ gtk_widget_size_allocate (priv->vsb, &child_allocation);
+ } else if (GTK_WIDGET_VISIBLE (priv->vsb))
+ gtk_widget_hide (priv->vsb);
+}
+
+/* Expose handler for the scroll frame widget */
+static gint
+e_scroll_frame_expose (GtkWidget *widget, GdkEventExpose *event)
+{
+ EScrollFrame *sf;
+
+ g_return_val_if_fail (widget != NULL, FALSE);
+ g_return_val_if_fail (E_IS_SCROLL_FRAME (widget), FALSE);
+ g_return_val_if_fail (event != NULL, FALSE);
+
+ sf = E_SCROLL_FRAME (widget);
+
+ if (GTK_WIDGET_DRAWABLE (widget))
+ draw_shadow (sf, &event->area);
+
+ if (GTK_WIDGET_CLASS (parent_class)->expose_event)
+ (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
+
+ return FALSE;
+}
+
+/* Add handler for the scroll frame widget */
+static void
+e_scroll_frame_add (GtkContainer *container, GtkWidget *child)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+ GtkBin *bin;
+
+ sf = E_SCROLL_FRAME (container);
+ priv = sf->priv;
+ bin = GTK_BIN (container);
+ g_return_if_fail (bin->child == NULL);
+
+ bin->child = child;
+ gtk_widget_set_parent (child, GTK_WIDGET (bin));
+
+ /* this is a temporary message */
+ if (!gtk_widget_set_scroll_adjustments (child,
+ gtk_range_get_adjustment (GTK_RANGE (priv->hsb)),
+ gtk_range_get_adjustment (GTK_RANGE (priv->vsb))))
+ g_warning ("e_scroll_frame_add(): cannot add non scrollable widget "
+ "use e_scroll_frame_add_with_viewport() instead");
+
+ if (GTK_WIDGET_REALIZED (child->parent))
+ gtk_widget_realize (child);
+
+ if (GTK_WIDGET_VISIBLE (child->parent) && GTK_WIDGET_VISIBLE (child)) {
+ if (GTK_WIDGET_MAPPED (child->parent))
+ gtk_widget_map (child);
+
+ gtk_widget_queue_resize (child);
+ }
+}
+
+/* Remove method for the scroll frame widget */
+static void
+e_scroll_frame_remove (GtkContainer *container, GtkWidget *child)
+{
+ g_return_if_fail (container != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (container));
+ g_return_if_fail (child != NULL);
+ g_return_if_fail (GTK_BIN (container)->child == child);
+
+ gtk_widget_set_scroll_adjustments (child, NULL, NULL);
+
+ /* chain parent class handler to remove child */
+ if (GTK_CONTAINER_CLASS (parent_class)->remove)
+ (* GTK_CONTAINER_CLASS (parent_class)->remove) (container, child);
+}
+
+/**
+ * e_scroll_frame_new:
+ * @hadj: If non-NULL, the adjustment to use for horizontal scrolling.
+ * @vadj: If non-NULL, the adjustment to use for vertical scrolling.
+ *
+ * Creates a new scroll frame widget.
+ *
+ * Return value: The newly-created scroll frame widget.
+ **/
+GtkWidget *
+e_scroll_frame_new (GtkAdjustment *hadj, GtkAdjustment *vadj)
+{
+ if (hadj)
+ g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadj), NULL);
+
+ if (vadj)
+ g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadj), NULL);
+
+ return gtk_widget_new (E_TYPE_SCROLL_FRAME,
+ "hadjustment", hadj,
+ "vadjustment", vadj,
+ NULL);
+}
+
+/* Callback used when one of the scroll frame widget's adjustments changes */
+static void
+adjustment_changed (GtkAdjustment *adj, gpointer data)
+{
+ EScrollFrame *sf;
+ ScrollFramePrivate *priv;
+
+ g_return_if_fail (adj != NULL);
+ g_return_if_fail (GTK_IS_ADJUSTMENT (adj));
+ g_return_if_fail (data != NULL);
+
+ sf = E_SCROLL_FRAME (data);
+ priv = sf->priv;
+
+ if (adj == gtk_range_get_adjustment (GTK_RANGE (priv->hsb))) {
+ if (priv->hsb_policy == GTK_POLICY_AUTOMATIC) {
+ gboolean visible;
+
+ visible = priv->hsb_visible;
+ priv->hsb_visible = (adj->upper - adj->lower > adj->page_size);
+ if (priv->hsb_visible != visible)
+ gtk_widget_queue_resize (GTK_WIDGET (sf));
+ }
+ } else if (adj == gtk_range_get_adjustment (GTK_RANGE (priv->vsb))) {
+ if (priv->vsb_policy == GTK_POLICY_AUTOMATIC) {
+ gboolean visible;
+
+ visible = priv->vsb_visible;
+ priv->vsb_visible = (adj->upper - adj->lower > adj->page_size);
+ if (priv->vsb_visible != visible)
+ gtk_widget_queue_resize (GTK_WIDGET (sf));
+ }
+ }
+}
+
+/**
+ * e_scroll_frame_set_hadjustment:
+ * @sf: A scroll frame widget.
+ * @adj: An adjustment.
+ *
+ * Sets the adjustment to be used for horizontal scrolling in a scroll frame
+ * widget.
+ **/
+void
+e_scroll_frame_set_hadjustment (EScrollFrame *sf, GtkAdjustment *adj)
+{
+ ScrollFramePrivate *priv;
+
+ g_return_if_fail (sf != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (sf));
+
+ priv = sf->priv;
+
+ if (adj)
+ g_return_if_fail (GTK_IS_ADJUSTMENT (adj));
+ else
+ adj = GTK_ADJUSTMENT (gtk_object_new (GTK_TYPE_ADJUSTMENT, NULL));
+
+ if (!priv->hsb) {
+ gtk_widget_push_composite_child ();
+ priv->hsb = gtk_hscrollbar_new (adj);
+ gtk_widget_set_composite_name (priv->hsb, "hscrollbar");
+ gtk_widget_pop_composite_child ();
+
+ gtk_widget_set_parent (priv->hsb, GTK_WIDGET (sf));
+ gtk_widget_ref (priv->hsb);
+ gtk_widget_show (priv->hsb);
+ } else {
+ GtkAdjustment *old_adj;
+
+ old_adj = gtk_range_get_adjustment (GTK_RANGE (priv->hsb));
+ if (old_adj == adj)
+ return;
+
+ gtk_signal_disconnect_by_func (GTK_OBJECT (old_adj),
+ GTK_SIGNAL_FUNC (adjustment_changed),
+ sf);
+ gtk_range_set_adjustment (GTK_RANGE (priv->hsb), adj);
+ }
+
+ adj = gtk_range_get_adjustment (GTK_RANGE (priv->hsb));
+ gtk_signal_connect (GTK_OBJECT (adj),
+ "changed",
+ GTK_SIGNAL_FUNC (adjustment_changed),
+ sf);
+ adjustment_changed (adj, sf);
+
+ if (GTK_BIN (sf)->child)
+ gtk_widget_set_scroll_adjustments (
+ GTK_BIN (sf)->child,
+ gtk_range_get_adjustment (GTK_RANGE (priv->hsb)),
+ gtk_range_get_adjustment (GTK_RANGE (priv->vsb)));
+}
+
+/**
+ * e_scroll_frame_set_vadjustment:
+ * @sf: A scroll frame widget.
+ * @adj: An adjustment.
+ *
+ * Sets the adjustment to be used for vertical scrolling in a scroll frame
+ * widget.
+ **/
+void
+e_scroll_frame_set_vadjustment (EScrollFrame *sf, GtkAdjustment *adj)
+{
+ ScrollFramePrivate *priv;
+
+ g_return_if_fail (sf != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (sf));
+
+ priv = sf->priv;
+
+ if (adj)
+ g_return_if_fail (GTK_IS_ADJUSTMENT (adj));
+ else
+ adj = GTK_ADJUSTMENT (gtk_object_new (GTK_TYPE_ADJUSTMENT, NULL));
+
+ if (!priv->vsb) {
+ gtk_widget_push_composite_child ();
+ priv->vsb = gtk_vscrollbar_new (adj);
+ gtk_widget_set_composite_name (priv->vsb, "vscrollbar");
+ gtk_widget_pop_composite_child ();
+
+ gtk_widget_set_parent (priv->vsb, GTK_WIDGET (sf));
+ gtk_widget_ref (priv->vsb);
+ gtk_widget_show (priv->vsb);
+ } else {
+ GtkAdjustment *old_adj;
+
+ old_adj = gtk_range_get_adjustment (GTK_RANGE (priv->vsb));
+ if (old_adj == adj)
+ return;
+
+ gtk_signal_disconnect_by_func (GTK_OBJECT (old_adj),
+ GTK_SIGNAL_FUNC (adjustment_changed),
+ sf);
+ gtk_range_set_adjustment (GTK_RANGE (priv->vsb), adj);
+ }
+
+ adj = gtk_range_get_adjustment (GTK_RANGE (priv->vsb));
+ gtk_signal_connect (GTK_OBJECT (adj),
+ "changed",
+ GTK_SIGNAL_FUNC (adjustment_changed),
+ sf);
+ adjustment_changed (adj, sf);
+
+ if (GTK_BIN (sf)->child)
+ gtk_widget_set_scroll_adjustments (
+ GTK_BIN (sf)->child,
+ gtk_range_get_adjustment (GTK_RANGE (priv->hsb)),
+ gtk_range_get_adjustment (GTK_RANGE (priv->vsb)));
+}
+
+/**
+ * e_scroll_frame_get_hadjustment:
+ * @sf: A scroll frame widget.
+ *
+ * Queries the horizontal adjustment of a scroll frame widget.
+ *
+ * Return value: The horizontal adjustment of the scroll frame, or NULL if none.
+ **/
+GtkAdjustment *
+e_scroll_frame_get_hadjustment (EScrollFrame *sf)
+{
+ ScrollFramePrivate *priv;
+
+ g_return_val_if_fail (sf != NULL, NULL);
+ g_return_val_if_fail (E_IS_SCROLL_FRAME (sf), NULL);
+
+ priv = sf->priv;
+
+ return priv->hsb ? gtk_range_get_adjustment (GTK_RANGE (priv->hsb)) : NULL;
+}
+
+/**
+ * e_scroll_frame_get_vadjustment:
+ * @sf: A scroll frame widget.
+ *
+ * Queries the vertical adjustment of a scroll frame widget.
+ *
+ * Return value: The vertical adjustment of the scroll frame, or NULL if none.
+ **/
+GtkAdjustment *
+e_scroll_frame_get_vadjustment (EScrollFrame *sf)
+{
+ ScrollFramePrivate *priv;
+
+ g_return_val_if_fail (sf != NULL, NULL);
+ g_return_val_if_fail (E_IS_SCROLL_FRAME (sf), NULL);
+
+ priv = sf->priv;
+
+ return priv->vsb ? gtk_range_get_adjustment (GTK_RANGE (priv->vsb)) : NULL;
+}
+
+/**
+ * e_scroll_frame_set_policy:
+ * @sf: A scroll frame widget.
+ * @hsb_policy: Policy for the horizontal scrollbar.
+ * @vsb_policy: Policy for the vertical scrollbar.
+ *
+ * Sets the scrollbar policies of a scroll frame widget. These determine when
+ * the scrollbars are to be shown or hidden.
+ **/
+void
+e_scroll_frame_set_policy (EScrollFrame *sf,
+ GtkPolicyType hsb_policy,
+ GtkPolicyType vsb_policy)
+{
+ ScrollFramePrivate *priv;
+
+ g_return_if_fail (sf != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (sf));
+
+ priv = sf->priv;
+
+ if (priv->hsb_policy == hsb_policy && priv->vsb_policy == vsb_policy)
+ return;
+
+ priv->hsb_policy = hsb_policy;
+ priv->vsb_policy = vsb_policy;
+
+ gtk_widget_queue_resize (GTK_WIDGET (sf));
+}
+
+/**
+ * e_scroll_frame_set_placement:
+ * @sf: A scroll frame widget.
+ * @frame_placement: Placement for the frame.
+ *
+ * Sets the placement of a scroll frame widget's frame with respect to its
+ * scrollbars.
+ **/
+void
+e_scroll_frame_set_placement (EScrollFrame *sf, GtkCornerType frame_placement)
+{
+ ScrollFramePrivate *priv;
+
+ g_return_if_fail (sf != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (sf));
+
+ priv = sf->priv;
+
+ if (priv->frame_placement == frame_placement)
+ return;
+
+ priv->frame_placement = frame_placement;
+ gtk_widget_queue_resize (GTK_WIDGET (sf));
+}
+
+/**
+ * e_scroll_frame_set_shadow_type:
+ * @sf: A scroll frame widget.
+ * @shadow_type: A shadow type.
+ *
+ * Sets the shadow type of a scroll frame widget. You can use this when you
+ * insert a child that does not paint a frame on its own.
+ **/
+void
+e_scroll_frame_set_shadow_type (EScrollFrame *sf, GtkShadowType shadow_type)
+{
+ ScrollFramePrivate *priv;
+
+ g_return_if_fail (sf != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (sf));
+ g_return_if_fail (shadow_type >= GTK_SHADOW_NONE && shadow_type <= GTK_SHADOW_ETCHED_OUT);
+
+ priv = sf->priv;
+
+ if (priv->shadow_type == shadow_type)
+ return;
+
+ priv->shadow_type = shadow_type;
+ gtk_widget_queue_resize (GTK_WIDGET (sf));
+}
+
+/**
+ * e_scroll_frame_set_scrollbar_spacing:
+ * @sf: A scroll frame widget.
+ * @spacing: Desired spacing in pixels.
+ *
+ * Sets the spacing between the frame and the scrollbars of a scroll frame
+ * widget.
+ **/
+void
+e_scroll_frame_set_scrollbar_spacing (EScrollFrame *sf, guint spacing)
+{
+ ScrollFramePrivate *priv;
+
+ g_return_if_fail (sf != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (sf));
+
+ priv = sf->priv;
+
+ if (priv->sb_spacing == spacing)
+ return;
+
+ priv->sb_spacing = spacing;
+ gtk_widget_queue_resize (GTK_WIDGET (sf));
+}
+
+/**
+ * e_scroll_frame_add_with_viewport:
+ * @sf: A scroll frame widget.
+ * @child: A widget.
+ *
+ * Creates a #GtkViewport and puts the specified child inside it, thus allowing
+ * the viewport to be scrolled by the scroll frame widget. This is meant to be
+ * used only when a child does not support the scrolling interface.
+ **/
+void
+e_scroll_frame_add_with_viewport (EScrollFrame *sf, GtkWidget *child)
+{
+ ScrollFramePrivate *priv;
+ GtkBin *bin;
+ GtkWidget *viewport;
+
+ g_return_if_fail (sf != NULL);
+ g_return_if_fail (E_IS_SCROLL_FRAME (sf));
+ g_return_if_fail (child != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (child));
+ g_return_if_fail (child->parent == NULL);
+
+ priv = sf->priv;
+ bin = GTK_BIN (sf);
+
+ if (bin->child != NULL) {
+ g_return_if_fail (GTK_IS_VIEWPORT (bin->child));
+ g_return_if_fail (GTK_BIN (bin->child)->child == NULL);
+
+ viewport = bin->child;
+ } else {
+ viewport = gtk_viewport_new (e_scroll_frame_get_hadjustment (sf),
+ e_scroll_frame_get_vadjustment (sf));
+ gtk_container_add (GTK_CONTAINER (sf), viewport);
+ }
+
+ gtk_widget_show (viewport);
+ gtk_container_add (GTK_CONTAINER (viewport), child);
+}
diff --git a/widgets/misc/e-scroll-frame.h b/widgets/misc/e-scroll-frame.h
new file mode 100644
index 0000000000..4bdeee3e1d
--- /dev/null
+++ b/widgets/misc/e-scroll-frame.h
@@ -0,0 +1,95 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * 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-1999. 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/.
+ */
+
+/* EScrollFrame based on GtkScrolledWindow.
+ *
+ * Modifications by Federico Mena <federico@helixcode.com>
+ */
+
+#ifndef __E_SCROLL_FRAME_H__
+#define __E_SCROLL_FRAME_H__
+
+
+#include <gdk/gdk.h>
+#include <gtk/gtkbin.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define E_TYPE_SCROLL_FRAME (e_scroll_frame_get_type ())
+#define E_SCROLL_FRAME(obj) (GTK_CHECK_CAST ((obj), E_TYPE_SCROLL_FRAME, EScrollFrame))
+#define E_SCROLL_FRAME_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), E_TYPE_SCROLL_FRAME, \
+ EScrollFrameClass))
+#define E_IS_SCROLL_FRAME(obj) (GTK_CHECK_TYPE ((obj), E_TYPE_SCROLL_FRAME))
+#define E_IS_SCROLL_FRAME_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), E_TYPE_SCROLL_FRAME))
+
+
+typedef struct _EScrollFrame EScrollFrame;
+typedef struct _EScrollFrameClass EScrollFrameClass;
+
+struct _EScrollFrame
+{
+ GtkBin bin;
+
+ /* Private data */
+ gpointer priv;
+};
+
+struct _EScrollFrameClass
+{
+ GtkBinClass parent_class;
+};
+
+
+GtkType e_scroll_frame_get_type (void);
+GtkWidget *e_scroll_frame_new (GtkAdjustment *hadj, GtkAdjustment *vadj);
+
+void e_scroll_frame_set_hadjustment (EScrollFrame *sf, GtkAdjustment *adj);
+void e_scroll_frame_set_vadjustment (EScrollFrame *sf, GtkAdjustment *adj);
+
+GtkAdjustment *e_scroll_frame_get_hadjustment (EScrollFrame *sf);
+GtkAdjustment *e_scroll_frame_get_vadjustment (EScrollFrame *sf);
+
+void e_scroll_frame_set_policy (EScrollFrame *sf,
+ GtkPolicyType hsb_policy,
+ GtkPolicyType vsb_policy);
+
+void e_scroll_frame_set_placement (EScrollFrame *sf, GtkCornerType frame_placement);
+void e_scroll_frame_set_shadow_type (EScrollFrame *sf, GtkShadowType shadow_type);
+void e_scroll_frame_set_scrollbar_spacing (EScrollFrame *sf, guint spacing);
+
+void e_scroll_frame_add_with_viewport (EScrollFrame *sf, GtkWidget *child);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __E_SCROLL_FRAME_H__ */