/* 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 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-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 "config.h"

#include <math.h>

#include <gdk/gdkkeysyms.h>

#include "gtkbindings.h"

#include "gtkmarshalers.h"

#include "gtkscrolledwindow.h"

#include "gtkwindow.h"

#include "gtkprivate.h"

#include "gtkintl.h"

#include "gtkalias.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_size_request().

 *

 * a scrolled window needs (for implementing 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.

 */

#define DEFAULT_SCROLLBAR_SPACING  3

typedef struct {

	gboolean window_placement_set;

	GtkCornerType real_window_placement;

} GtkScrolledWindowPrivate;

#define GTK_SCROLLED_WINDOW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_SCROLLED_WINDOW, GtkScrolledWindowPrivate))

enum {

  PROP_0,

  PROP_HADJUSTMENT,

  PROP_VADJUSTMENT,

  PROP_HSCROLLBAR_POLICY,

  PROP_VSCROLLBAR_POLICY,

  PROP_WINDOW_PLACEMENT,

  PROP_WINDOW_PLACEMENT_SET,

  PROP_SHADOW_TYPE

};

/* Signals */

enum

{

  SCROLL_CHILD,

  MOVE_FOCUS_OUT,

  LAST_SIGNAL

};

static void     gtk_scrolled_window_destroy            (GtkObject         *object);

static void     gtk_scrolled_window_set_property       (GObject           *object,

                                                        guint              prop_id,

                                                        const GValue      *value,

                                                        GParamSpec        *pspec);

static void     gtk_scrolled_window_get_property       (GObject           *object,

                                                        guint              prop_id,

                                                        GValue            *value,

                                                        GParamSpec        *pspec);

static void     gtk_scrolled_window_screen_changed     (GtkWidget         *widget,

                                                        GdkScreen         *previous_screen);

static gboolean gtk_scrolled_window_expose             (GtkWidget         *widget,

                                                        GdkEventExpose    *event);

static void     gtk_scrolled_window_size_request       (GtkWidget         *widget,

                                                        GtkRequisition    *requisition);

static void     gtk_scrolled_window_size_allocate      (GtkWidget         *widget,

                                                        GtkAllocation     *allocation);

static gboolean gtk_scrolled_window_scroll_event       (GtkWidget         *widget,

                                                        GdkEventScroll    *event);

static gboolean gtk_scrolled_window_focus              (GtkWidget         *widget,

                                                        GtkDirectionType   direction);

static void     gtk_scrolled_window_add                (GtkContainer      *container,

                                                        GtkWidget         *widget);

static void     gtk_scrolled_window_remove             (GtkContainer      *container,

                                                        GtkWidget         *widget);

static void     gtk_scrolled_window_forall             (GtkContainer      *container,

                                                        gboolean           include_internals,

                                                        GtkCallback        callback,

                                                        gpointer           callback_data);

static gboolean gtk_scrolled_window_scroll_child       (GtkScrolledWindow *scrolled_window,

                                                        GtkScrollType      scroll,

                                                        gboolean           horizontal);

static void     gtk_scrolled_window_move_focus_out     (GtkScrolledWindow *scrolled_window,

                                                        GtkDirectionType   direction_type);

static void     gtk_scrolled_window_relative_allocation(GtkWidget         *widget,

                                                        GtkAllocation     *allocation);

static void     gtk_scrolled_window_adjustment_changed (GtkAdjustment     *adjustment,

                                                        gpointer           data);

static void  gtk_scrolled_window_update_real_placement (GtkScrolledWindow *scrolled_window);

static guint signals[LAST_SIGNAL] = {0};

G_DEFINE_TYPE (GtkScrolledWindow, gtk_scrolled_window, GTK_TYPE_BIN)

static void

add_scroll_binding (GtkBindingSet  *binding_set,

		    guint           keyval,

		    GdkModifierType mask,

		    GtkScrollType   scroll,

		    gboolean        horizontal)

{

  guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;

  gtk_binding_entry_add_signal (binding_set, keyval, mask,

                                "scroll-child", 2,

                                GTK_TYPE_SCROLL_TYPE, scroll,

				G_TYPE_BOOLEAN, horizontal);

  gtk_binding_entry_add_signal (binding_set, keypad_keyval, mask,

                                "scroll-child", 2,

                                GTK_TYPE_SCROLL_TYPE, scroll,

				G_TYPE_BOOLEAN, horizontal);

}

static void

add_tab_bindings (GtkBindingSet    *binding_set,

		  GdkModifierType   modifiers,

		  GtkDirectionType  direction)

{

  gtk_binding_entry_add_signal (binding_set, GDK_Tab, modifiers,

                                "move-focus-out", 1,

                                GTK_TYPE_DIRECTION_TYPE, direction);

  gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, modifiers,

                                "move-focus-out", 1,

                                GTK_TYPE_DIRECTION_TYPE, direction);

}

static void

gtk_scrolled_window_class_init (GtkScrolledWindowClass *class)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (class);

  GtkObjectClass *object_class;

  GtkWidgetClass *widget_class;

  GtkContainerClass *container_class;

  GtkBindingSet *binding_set;

  object_class = (GtkObjectClass*) class;

  widget_class = (GtkWidgetClass*) class;

  container_class = (GtkContainerClass*) class;

  gobject_class->set_property = gtk_scrolled_window_set_property;

  gobject_class->get_property = gtk_scrolled_window_get_property;

  object_class->destroy = gtk_scrolled_window_destroy;

  widget_class->screen_changed = gtk_scrolled_window_screen_changed;

  widget_class->expose_event = gtk_scrolled_window_expose;

  widget_class->size_request = gtk_scrolled_window_size_request;

  widget_class->size_allocate = gtk_scrolled_window_size_allocate;

  widget_class->scroll_event = gtk_scrolled_window_scroll_event;

  widget_class->focus = gtk_scrolled_window_focus;

  container_class->add = gtk_scrolled_window_add;

  container_class->remove = gtk_scrolled_window_remove;

  container_class->forall = gtk_scrolled_window_forall;

  class->scrollbar_spacing = -1;

  class->scroll_child = gtk_scrolled_window_scroll_child;

  class->move_focus_out = gtk_scrolled_window_move_focus_out;

  g_object_class_install_property (gobject_class,

				   PROP_HADJUSTMENT,

				   g_param_spec_object ("hadjustment",

							P_("Horizontal Adjustment"),

							P_("The GtkAdjustment for the horizontal position"),

							GTK_TYPE_ADJUSTMENT,

							GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));

  g_object_class_install_property (gobject_class,

				   PROP_VADJUSTMENT,

				   g_param_spec_object ("vadjustment",

							P_("Vertical Adjustment"),

							P_("The GtkAdjustment for the vertical position"),

							GTK_TYPE_ADJUSTMENT,

							GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));

  g_object_class_install_property (gobject_class,

                                   PROP_HSCROLLBAR_POLICY,

                                   g_param_spec_enum ("hscrollbar-policy",

                                                      P_("Horizontal Scrollbar Policy"),

                                                      P_("When the horizontal scrollbar is displayed"),

						      GTK_TYPE_POLICY_TYPE,

						      GTK_POLICY_ALWAYS,

                                                      GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));

  g_object_class_install_property (gobject_class,

                                   PROP_VSCROLLBAR_POLICY,

                                   g_param_spec_enum ("vscrollbar-policy",

                                                      P_("Vertical Scrollbar Policy"),

                                                      P_("When the vertical scrollbar is displayed"),

						      GTK_TYPE_POLICY_TYPE,

						      GTK_POLICY_ALWAYS,

                                                      GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));

  g_object_class_install_property (gobject_class,

                                   PROP_WINDOW_PLACEMENT,

                                   g_param_spec_enum ("window-placement",

                                                      P_("Window Placement"),

                                                      P_("Where the contents are located with respect to the scrollbars. This property only takes effect if \"window-placement-set\" is TRUE."),

						      GTK_TYPE_CORNER_TYPE,

						      GTK_CORNER_TOP_LEFT,

                                                      GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));

  /**

   * GtkScrolledWindow:window-placement-set:

   *

   * Whether "window-placement" should be used to determine the location 

   * of the contents with respect to the scrollbars. Otherwise, the 

   * "gtk-scrolled-window-placement" setting is used.

   *

   * Since: 2.10

   */

  g_object_class_install_property (gobject_class,

                                   PROP_WINDOW_PLACEMENT_SET,

                                   g_param_spec_boolean ("window-placement-set",

					   		 P_("Window Placement Set"),

							 P_("Whether \"window-placement\" should be used to determine the location of the contents with respect to the scrollbars."),

							 FALSE,

							 GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));

  g_object_class_install_property (gobject_class,

                                   PROP_SHADOW_TYPE,

                                   g_param_spec_enum ("shadow-type",

                                                      P_("Shadow Type"),

                                                      P_("Style of bevel around the contents"),

						      GTK_TYPE_SHADOW_TYPE,

						      GTK_SHADOW_NONE,

                                                      GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));

  /**

   * GtkScrolledWindow:scrollbars-within-bevel:

   *

   * Whether to place scrollbars within the scrolled window's bevel.

   *

   * Since: 2.12

   */

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_boolean ("scrollbars-within-bevel",

							         P_("Scrollbars within bevel"),

							         P_("Place scrollbars within the scrolled window's bevel"),

							         FALSE,

							         GTK_PARAM_READABLE));

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("scrollbar-spacing",

							     P_("Scrollbar spacing"),

							     P_("Number of pixels between the scrollbars and the scrolled window"),

							     0,

							     G_MAXINT,

							     DEFAULT_SCROLLBAR_SPACING,

							     GTK_PARAM_READABLE));

  /**

   * GtkScrolledWindow::scroll-child:

   * @scrolled_window: a #GtkScrolledWindow

   * @scroll: a #GtkScrollType describing how much to scroll

   * @horizontal: whether the keybinding scrolls the child

   *   horizontally or not

   *

   * The ::scroll-child signal is a

   * <link linkend="keybinding-signals">keybinding signal</link>

   * which gets emitted when a keybinding that scrolls is pressed.

   * The horizontal or vertical adjustment is updated which triggers a

   * signal that the scrolled windows child may listen to and scroll itself.

   */

  signals[SCROLL_CHILD] =

    g_signal_new (I_("scroll-child"),

                  G_TYPE_FROM_CLASS (object_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

                  G_STRUCT_OFFSET (GtkScrolledWindowClass, scroll_child),

                  NULL, NULL,

                  _gtk_marshal_BOOLEAN__ENUM_BOOLEAN,

                  G_TYPE_BOOLEAN, 2,

                  GTK_TYPE_SCROLL_TYPE,

		  G_TYPE_BOOLEAN);

  signals[MOVE_FOCUS_OUT] =

    g_signal_new (I_("move-focus-out"),

                  G_TYPE_FROM_CLASS (object_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

                  G_STRUCT_OFFSET (GtkScrolledWindowClass, move_focus_out),

                  NULL, NULL,

                  _gtk_marshal_VOID__ENUM,

                  G_TYPE_NONE, 1,

                  GTK_TYPE_DIRECTION_TYPE);

  binding_set = gtk_binding_set_by_class (class);

  add_scroll_binding (binding_set, GDK_Left,  GDK_CONTROL_MASK, GTK_SCROLL_STEP_BACKWARD, TRUE);

  add_scroll_binding (binding_set, GDK_Right, GDK_CONTROL_MASK, GTK_SCROLL_STEP_FORWARD,  TRUE);

  add_scroll_binding (binding_set, GDK_Up,    GDK_CONTROL_MASK, GTK_SCROLL_STEP_BACKWARD, FALSE);

  add_scroll_binding (binding_set, GDK_Down,  GDK_CONTROL_MASK, GTK_SCROLL_STEP_FORWARD,  FALSE);

  add_scroll_binding (binding_set, GDK_Page_Up,   GDK_CONTROL_MASK, GTK_SCROLL_PAGE_BACKWARD, TRUE);

  add_scroll_binding (binding_set, GDK_Page_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_FORWARD,  TRUE);

  add_scroll_binding (binding_set, GDK_Page_Up,   0,                GTK_SCROLL_PAGE_BACKWARD, FALSE);

  add_scroll_binding (binding_set, GDK_Page_Down, 0,                GTK_SCROLL_PAGE_FORWARD,  FALSE);

  add_scroll_binding (binding_set, GDK_Home, GDK_CONTROL_MASK, GTK_SCROLL_START, TRUE);

  add_scroll_binding (binding_set, GDK_End,  GDK_CONTROL_MASK, GTK_SCROLL_END,   TRUE);

  add_scroll_binding (binding_set, GDK_Home, 0,                GTK_SCROLL_START, FALSE);

  add_scroll_binding (binding_set, GDK_End,  0,                GTK_SCROLL_END,   FALSE);

  add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);

  add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);

  g_type_class_add_private (class, sizeof (GtkScrolledWindowPrivate));

}

static void

gtk_scrolled_window_init (GtkScrolledWindow *scrolled_window)

{

  gtk_widget_set_has_window (GTK_WIDGET (scrolled_window), FALSE);

  gtk_widget_set_can_focus (GTK_WIDGET (scrolled_window), TRUE);

  scrolled_window->hscrollbar = NULL;

  scrolled_window->vscrollbar = NULL;

  scrolled_window->hscrollbar_policy = GTK_POLICY_ALWAYS;

  scrolled_window->vscrollbar_policy = GTK_POLICY_ALWAYS;

  scrolled_window->hscrollbar_visible = FALSE;

  scrolled_window->vscrollbar_visible = FALSE;

  scrolled_window->focus_out = FALSE;

  scrolled_window->window_placement = GTK_CORNER_TOP_LEFT;

  gtk_scrolled_window_update_real_placement (scrolled_window);

}

/**

 * gtk_scrolled_window_new:

 * @hadjustment: (allow-none): horizontal adjustment

 * @vadjustment: (allow-none): vertical adjustment

 *

 * Creates a new scrolled window.

 *

 * The two arguments are the scrolled window's adjustments; these will be

 * shared with the scrollbars and the child widget to keep the bars in sync 

 * with the child. Usually you want to pass %NULL for the adjustments, which 

 * will cause the scrolled window to create them for you.

 *

 * Returns: a new scrolled window

 */

GtkWidget*

gtk_scrolled_window_new (GtkAdjustment *hadjustment,

			 GtkAdjustment *vadjustment)

{

  GtkWidget *scrolled_window;

  if (hadjustment)

    g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadjustment), NULL);

  if (vadjustment)

    g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadjustment), NULL);

  scrolled_window = g_object_new (GTK_TYPE_SCROLLED_WINDOW,

				    "hadjustment", hadjustment,

				    "vadjustment", vadjustment,

				    NULL);

  return scrolled_window;

}

/**

 * gtk_scrolled_window_set_hadjustment:

 * @scrolled_window: a #GtkScrolledWindow

 * @hadjustment: horizontal scroll adjustment

 *

 * Sets the #GtkAdjustment for the horizontal scrollbar.

 */

void

gtk_scrolled_window_set_hadjustment (GtkScrolledWindow *scrolled_window,

				     GtkAdjustment     *hadjustment)

{

  GtkBin *bin;

  g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));

  if (hadjustment)

    g_return_if_fail (GTK_IS_ADJUSTMENT (hadjustment));

  else

    hadjustment = (GtkAdjustment*) g_object_new (GTK_TYPE_ADJUSTMENT, NULL);

  bin = GTK_BIN (scrolled_window);

  if (!scrolled_window->hscrollbar)

    {

      gtk_widget_push_composite_child ();

      scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);

      gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");

      gtk_widget_pop_composite_child ();

      gtk_widget_set_parent (scrolled_window->hscrollbar, GTK_WIDGET (scrolled_window));

      g_object_ref (scrolled_window->hscrollbar);

      gtk_widget_show (scrolled_window->hscrollbar);

    }

  else

    {

      GtkAdjustment *old_adjustment;

      old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));

      if (old_adjustment == hadjustment)

	return;

      g_signal_handlers_disconnect_by_func (old_adjustment,

					    gtk_scrolled_window_adjustment_changed,

					    scrolled_window);

      gtk_range_set_adjustment (GTK_RANGE (scrolled_window->hscrollbar),

				hadjustment);

    }

  hadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));

  g_signal_connect (hadjustment,

		    "changed",

		    G_CALLBACK (gtk_scrolled_window_adjustment_changed),

		    scrolled_window);

  gtk_scrolled_window_adjustment_changed (hadjustment, scrolled_window);

  if (bin->child)

    gtk_widget_set_scroll_adjustments (bin->child,

				       gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),

				       gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));

  g_object_notify (G_OBJECT (scrolled_window), "hadjustment");

}

/**

 * gtk_scrolled_window_set_vadjustment:

 * @scrolled_window: a #GtkScrolledWindow

 * @vadjustment: vertical scroll adjustment

 *

 * Sets the #GtkAdjustment for the vertical scrollbar.

 */

void

gtk_scrolled_window_set_vadjustment (GtkScrolledWindow *scrolled_window,

				     GtkAdjustment     *vadjustment)

{

  GtkBin *bin;

  g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));

  if (vadjustment)

    g_return_if_fail (GTK_IS_ADJUSTMENT (vadjustment));

  else

    vadjustment = (GtkAdjustment*) g_object_new (GTK_TYPE_ADJUSTMENT, NULL);

  bin = GTK_BIN (scrolled_window);

  if (!scrolled_window->vscrollbar)

    {

      gtk_widget_push_composite_child ();

      scrolled_window->vscrollbar = gtk_vscrollbar_new (vadjustment);

      gtk_widget_set_composite_name (scrolled_window->vscrollbar, "vscrollbar");

      gtk_widget_pop_composite_child ();

      gtk_widget_set_parent (scrolled_window->vscrollbar, GTK_WIDGET (scrolled_window));

      g_object_ref (scrolled_window->vscrollbar);

      gtk_widget_show (scrolled_window->vscrollbar);

    }

  else

    {

      GtkAdjustment *old_adjustment;

      old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));

      if (old_adjustment == vadjustment)

	return;

      g_signal_handlers_disconnect_by_func (old_adjustment,

					    gtk_scrolled_window_adjustment_changed,

					    scrolled_window);

      gtk_range_set_adjustment (GTK_RANGE (scrolled_window->vscrollbar),

				vadjustment);

    }

  vadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));

  g_signal_connect (vadjustment,

		    "changed",

		    G_CALLBACK (gtk_scrolled_window_adjustment_changed),

		    scrolled_window);

  gtk_scrolled_window_adjustment_changed (vadjustment, scrolled_window);

  if (bin->child)

    gtk_widget_set_scroll_adjustments (bin->child,

				       gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),

				       gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));

  g_object_notify (G_OBJECT (scrolled_window), "vadjustment");

}

/**

 * gtk_scrolled_window_get_hadjustment:

 * @scrolled_window: a #GtkScrolledWindow

 *

 * Returns the horizontal scrollbar's adjustment, used to connect the

 * horizontal scrollbar to the child widget's horizontal scroll

 * functionality.

 *

 * Returns: (transfer none): the horizontal #GtkAdjustment

 */

GtkAdjustment*

gtk_scrolled_window_get_hadjustment (GtkScrolledWindow *scrolled_window)

{

  g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);

  return (scrolled_window->hscrollbar ?

	  gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)) :

	  NULL);

}

/**

 * gtk_scrolled_window_get_vadjustment:

 * @scrolled_window: a #GtkScrolledWindow

 * 

 * Returns the vertical scrollbar's adjustment, used to connect the

 * vertical scrollbar to the child widget's vertical scroll functionality.

 * 

 * Returns: (transfer none): the vertical #GtkAdjustment

 */

GtkAdjustment*

gtk_scrolled_window_get_vadjustment (GtkScrolledWindow *scrolled_window)

{

  g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);

  return (scrolled_window->vscrollbar ?

	  gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)) :

	  NULL);

}

/**

 * gtk_scrolled_window_get_hscrollbar:

 * @scrolled_window: a #GtkScrolledWindow

 *

 * Returns the horizontal scrollbar of @scrolled_window.

 *

 * Returns: (transfer none): the horizontal scrollbar of the scrolled window,

 *     or %NULL if it does not have one.

 *

 * Since: 2.8

 */

GtkWidget*

gtk_scrolled_window_get_hscrollbar (GtkScrolledWindow *scrolled_window)

{

  g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);

  return scrolled_window->hscrollbar;

}

/**

 * gtk_scrolled_window_get_vscrollbar:

 * @scrolled_window: a #GtkScrolledWindow

 * 

 * Returns the vertical scrollbar of @scrolled_window.

 *

 * Returns: (transfer none): the vertical scrollbar of the scrolled window,

 *     or %NULL if it does not have one.

 *

 * Since: 2.8

 */

GtkWidget*

gtk_scrolled_window_get_vscrollbar (GtkScrolledWindow *scrolled_window)

{

  g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);

  return scrolled_window->vscrollbar;

}

/**

 * gtk_scrolled_window_set_policy:

 * @scrolled_window: a #GtkScrolledWindow

 * @hscrollbar_policy: policy for horizontal bar

 * @vscrollbar_policy: policy for vertical bar

 * 

 * Sets the scrollbar policy for the horizontal and vertical scrollbars.

 *

 * The policy determines when the scrollbar should appear; it is a value

 * from the #GtkPolicyType enumeration. If %GTK_POLICY_ALWAYS, the

 * scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is

 * never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only

 * if needed (that is, if the slider part of the bar would be smaller

 * than the trough - the display is larger than the page size).

 */

void

gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,

				GtkPolicyType      hscrollbar_policy,

				GtkPolicyType      vscrollbar_policy)

{

  GObject *object = G_OBJECT (scrolled_window);

  g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));

  if ((scrolled_window->hscrollbar_policy != hscrollbar_policy) ||

      (scrolled_window->vscrollbar_policy != vscrollbar_policy))

    {

      scrolled_window->hscrollbar_policy = hscrollbar_policy;

      scrolled_window->vscrollbar_policy = vscrollbar_policy;

      gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));

      g_object_freeze_notify (object);

      g_object_notify (object, "hscrollbar-policy");

      g_object_notify (object, "vscrollbar-policy");

      g_object_thaw_notify (object);

    }

}

/**

 * gtk_scrolled_window_get_policy:

 * @scrolled_window: a #GtkScrolledWindow

 * @hscrollbar_policy: (out) (allow-none): location to store the policy 

 *     for the horizontal scrollbar, or %NULL.

 * @vscrollbar_policy: (out) (allow-none): location to store the policy

 *     for the vertical scrollbar, or %NULL.

 * 

 * Retrieves the current policy values for the horizontal and vertical

 * scrollbars. See gtk_scrolled_window_set_policy().

 */

void

gtk_scrolled_window_get_policy (GtkScrolledWindow *scrolled_window,

				GtkPolicyType     *hscrollbar_policy,

				GtkPolicyType     *vscrollbar_policy)

{

  g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));

  if (hscrollbar_policy)

    *hscrollbar_policy = scrolled_window->hscrollbar_policy;

  if (vscrollbar_policy)

    *vscrollbar_policy = scrolled_window->vscrollbar_policy;

}

static void

gtk_scrolled_window_update_real_placement (GtkScrolledWindow *scrolled_window)

{

  GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);

  GtkSettings *settings;

  settings = gtk_widget_get_settings (GTK_WIDGET (scrolled_window));

  if (priv->window_placement_set || settings == NULL)

    priv->real_window_placement = scrolled_window->window_placement;

  else

    g_object_get (settings,

		  "gtk-scrolled-window-placement",

		  &priv->real_window_placement,

		  NULL);

}

static void

gtk_scrolled_window_set_placement_internal (GtkScrolledWindow *scrolled_window,

					    GtkCornerType      window_placement)

{

  if (scrolled_window->window_placement != window_placement)

    {

      scrolled_window->window_placement = window_placement;

      gtk_scrolled_window_update_real_placement (scrolled_window);

      gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));

      g_object_notify (G_OBJECT (scrolled_window), "window-placement");

    }

}

static void

gtk_scrolled_window_set_placement_set (GtkScrolledWindow *scrolled_window,

				       gboolean           placement_set,

				       gboolean           emit_resize)

{

  GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);

  if (priv->window_placement_set != placement_set)

    {

      priv->window_placement_set = placement_set;

      gtk_scrolled_window_update_real_placement (scrolled_window);

      if (emit_resize)

        gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));

      g_object_notify (G_OBJECT (scrolled_window), "window-placement-set");

    }

}

/**

 * gtk_scrolled_window_set_placement:

 * @scrolled_window: a #GtkScrolledWindow

 * @window_placement: position of the child window

 *

 * Sets the placement of the contents with respect to the scrollbars

 * for the scrolled window.

 * 

 * The default is %GTK_CORNER_TOP_LEFT, meaning the child is

 * in the top left, with the scrollbars underneath and to the right.

 * Other values in #GtkCornerType are %GTK_CORNER_TOP_RIGHT,

 * %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT.

 *

 * See also gtk_scrolled_window_get_placement() and

 * gtk_scrolled_window_unset_placement().

 */

void

gtk_scrolled_window_set_placement (GtkScrolledWindow *scrolled_window,

				   GtkCornerType      window_placement)

{

  g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));

  gtk_scrolled_window_set_placement_set (scrolled_window, TRUE, FALSE);

  gtk_scrolled_window_set_placement_internal (scrolled_window, window_placement);

}

/**

 * gtk_scrolled_window_get_placement:

 * @scrolled_window: a #GtkScrolledWindow

 *

 * Gets the placement of the contents with respect to the scrollbars

 * for the scrolled window. See gtk_scrolled_window_set_placement().

 *

 * Return value: the current placement value.

 *

 * See also gtk_scrolled_window_set_placement() and

 * gtk_scrolled_window_unset_placement().

 **/

GtkCornerType

gtk_scrolled_window_get_placement (GtkScrolledWindow *scrolled_window)

{

  g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), GTK_CORNER_TOP_LEFT);

  return scrolled_window->window_placement;

}

/**

 * gtk_scrolled_window_unset_placement:

 * @scrolled_window: a #GtkScrolledWindow

 *

 * Unsets the placement of the contents with respect to the scrollbars

 * for the scrolled window. If no window placement is set for a scrolled

 * window, it obeys the "gtk-scrolled-window-placement" XSETTING.

 *

 * See also gtk_scrolled_window_set_placement() and

 * gtk_scrolled_window_get_placement().

 *

 * Since: 2.10

 **/

void

gtk_scrolled_window_unset_placement (GtkScrolledWindow *scrolled_window)

{

  GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);

  g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));

  if (priv->window_placement_set)

    {

      priv->window_placement_set = FALSE;

      gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));

      g_object_notify (G_OBJECT (scrolled_window), "window-placement-set");

    }

}

/**

 * gtk_scrolled_window_set_shadow_type:

 * @scrolled_window: a #GtkScrolledWindow

 * @type: kind of shadow to draw around scrolled window contents

 *

 * Changes the type of shadow drawn around the contents of

 * @scrolled_window.

 * 

 **/

void

gtk_scrolled_window_set_shadow_type (GtkScrolledWindow *scrolled_window,

				     GtkShadowType      type)

{

  g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));

  g_return_if_fail (type >= GTK_SHADOW_NONE && type <= GTK_SHADOW_ETCHED_OUT);

  if (scrolled_window->shadow_type != type)

    {

      scrolled_window->shadow_type = type;

      if (gtk_widget_is_drawable (GTK_WIDGET (scrolled_window)))

	gtk_widget_queue_draw (GTK_WIDGET (scrolled_window));

      gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));

      g_object_notify (G_OBJECT (scrolled_window), "shadow-type");

    }

}

/**

 * gtk_scrolled_window_get_shadow_type:

 * @scrolled_window: a #GtkScrolledWindow

 *

 * Gets the shadow type of the scrolled window. See 

 * gtk_scrolled_window_set_shadow_type().

 *

 * Return value: the current shadow type

 **/

GtkShadowType

gtk_scrolled_window_get_shadow_type (GtkScrolledWindow *scrolled_window)

{

  g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_NONE);

  return scrolled_window->shadow_type;

}

static void

gtk_scrolled_window_destroy (GtkObject *object)

{

  GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);

  if (scrolled_window->hscrollbar)

    {

      g_signal_handlers_disconnect_by_func (gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),

					    gtk_scrolled_window_adjustment_changed,

					    scrolled_window);

      gtk_widget_unparent (scrolled_window->hscrollbar);

      gtk_widget_destroy (scrolled_window->hscrollbar);

      g_object_unref (scrolled_window->hscrollbar);

      scrolled_window->hscrollbar = NULL;

    }

  if (scrolled_window->vscrollbar)

    {

      g_signal_handlers_disconnect_by_func (gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)),

					    gtk_scrolled_window_adjustment_changed,

					    scrolled_window);

      gtk_widget_unparent (scrolled_window->vscrollbar);

      gtk_widget_destroy (scrolled_window->vscrollbar);

      g_object_unref (scrolled_window->vscrollbar);

      scrolled_window->vscrollbar = NULL;

    }

  GTK_OBJECT_CLASS (gtk_scrolled_window_parent_class)->destroy (object);

}

static void

gtk_scrolled_window_set_property (GObject      *object,

				  guint         prop_id,

				  const GValue *value,

				  GParamSpec   *pspec)

{

  GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);