{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

GtkScrolledWindow is a container that accepts a single child widget, makes
that child scrollable using either internally added scrollbars or externally
associated adjustments, and optionally draws a frame around the child.

Widgets with native scrolling support, i.e. those whose classes implement the
'GI.Gtk.Interfaces.Scrollable.Scrollable' interface, are added directly. For other types of widget, the
class 'GI.Gtk.Objects.Viewport.Viewport' acts as an adaptor, giving scrollability to other widgets.
GtkScrolledWindow’s implementation of 'GI.Gtk.Objects.Container.containerAdd' intelligently
accounts for whether or not the added child is a 'GI.Gtk.Interfaces.Scrollable.Scrollable'. If it isn’t,
'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' wraps the child in a 'GI.Gtk.Objects.Viewport.Viewport' and adds that for you.
Therefore, you can just add any child widget and not worry about the details.

If 'GI.Gtk.Objects.Container.containerAdd' has added a 'GI.Gtk.Objects.Viewport.Viewport' for you, you can remove
both your added child widget from the 'GI.Gtk.Objects.Viewport.Viewport', and the 'GI.Gtk.Objects.Viewport.Viewport'
from the GtkScrolledWindow, with either of these calls:

=== /C code/
>
>gtk_container_remove (GTK_CONTAINER (scrolled_window),
>                      child_widget);
>// or
>gtk_container_remove (GTK_CONTAINER (scrolled_window),
>                      gtk_bin_get_child (GTK_BIN (scrolled_window)));


Unless 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow':@/policy/@ is GTK_POLICY_NEVER or GTK_POLICY_EXTERNAL,
GtkScrolledWindow adds internal 'GI.Gtk.Objects.Scrollbar.Scrollbar' widgets around its child. The
scroll position of the child, and if applicable the scrollbars, is controlled
by the 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow':@/hadjustment/@ and 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow':@/vadjustment/@
that are associated with the GtkScrolledWindow. See the docs on 'GI.Gtk.Objects.Scrollbar.Scrollbar'
for the details, but note that the “step_increment” and “page_increment”
fields are only effective if the policy causes scrollbars to be present.

If a GtkScrolledWindow doesn’t behave quite as you would like, or
doesn’t have exactly the right layout, it’s very possible to set up
your own scrolling with 'GI.Gtk.Objects.Scrollbar.Scrollbar' and for example a 'GI.Gtk.Objects.Grid.Grid'.

= Touch support

GtkScrolledWindow has built-in support for touch devices. When a
touchscreen is used, swiping will move the scrolled window, and will
expose \'kinetic\' behavior. This can be turned off with the
'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow':@/kinetic-scrolling/@ property if it is undesired.

GtkScrolledWindow also displays visual \'overshoot\' indication when
the content is pulled beyond the end, and this situation can be
captured with the 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow'::@/edge-overshot/@ signal.

If no mouse device is present, the scrollbars will overlayed as
narrow, auto-hiding indicators over the content. If traditional
scrollbars are desired although no mouse is present, this behaviour
can be turned off with the 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow':@/overlay-scrolling/@
property.

= CSS nodes

GtkScrolledWindow has a main CSS node with name scrolledwindow.

It uses subnodes with names overshoot and undershoot to
draw the overflow and underflow indications. These nodes get
the .left, .right, .top or .bottom style class added depending
on where the indication is drawn.

GtkScrolledWindow also sets the positional style classes (.left,
.right, .top, .bottom) and style classes related to overlay
scrolling (.overlay-indicator, .dragging, .hovering) on its scrollbars.

If both scrollbars are visible, the area where they meet is drawn
with a subnode named junction.
-}

module GI.Gtk.Objects.ScrolledWindow
    ( 

-- * Exported types
    ScrolledWindow(..)                      ,
    IsScrolledWindow                        ,
    toScrolledWindow                        ,
    noScrolledWindow                        ,


 -- * Methods
-- ** addWithViewport #method:addWithViewport#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowAddWithViewportMethodInfo ,
#endif
    scrolledWindowAddWithViewport           ,


-- ** getCaptureButtonPress #method:getCaptureButtonPress#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetCaptureButtonPressMethodInfo,
#endif
    scrolledWindowGetCaptureButtonPress     ,


-- ** getHadjustment #method:getHadjustment#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetHadjustmentMethodInfo  ,
#endif
    scrolledWindowGetHadjustment            ,


-- ** getHscrollbar #method:getHscrollbar#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetHscrollbarMethodInfo   ,
#endif
    scrolledWindowGetHscrollbar             ,


-- ** getKineticScrolling #method:getKineticScrolling#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetKineticScrollingMethodInfo,
#endif
    scrolledWindowGetKineticScrolling       ,


-- ** getMaxContentHeight #method:getMaxContentHeight#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetMaxContentHeightMethodInfo,
#endif
    scrolledWindowGetMaxContentHeight       ,


-- ** getMaxContentWidth #method:getMaxContentWidth#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetMaxContentWidthMethodInfo,
#endif
    scrolledWindowGetMaxContentWidth        ,


-- ** getMinContentHeight #method:getMinContentHeight#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetMinContentHeightMethodInfo,
#endif
    scrolledWindowGetMinContentHeight       ,


-- ** getMinContentWidth #method:getMinContentWidth#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetMinContentWidthMethodInfo,
#endif
    scrolledWindowGetMinContentWidth        ,


-- ** getOverlayScrolling #method:getOverlayScrolling#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetOverlayScrollingMethodInfo,
#endif
    scrolledWindowGetOverlayScrolling       ,


-- ** getPlacement #method:getPlacement#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetPlacementMethodInfo    ,
#endif
    scrolledWindowGetPlacement              ,


-- ** getPolicy #method:getPolicy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetPolicyMethodInfo       ,
#endif
    scrolledWindowGetPolicy                 ,


-- ** getPropagateNaturalHeight #method:getPropagateNaturalHeight#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetPropagateNaturalHeightMethodInfo,
#endif
    scrolledWindowGetPropagateNaturalHeight ,


-- ** getPropagateNaturalWidth #method:getPropagateNaturalWidth#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetPropagateNaturalWidthMethodInfo,
#endif
    scrolledWindowGetPropagateNaturalWidth  ,


-- ** getShadowType #method:getShadowType#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetShadowTypeMethodInfo   ,
#endif
    scrolledWindowGetShadowType             ,


-- ** getVadjustment #method:getVadjustment#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetVadjustmentMethodInfo  ,
#endif
    scrolledWindowGetVadjustment            ,


-- ** getVscrollbar #method:getVscrollbar#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowGetVscrollbarMethodInfo   ,
#endif
    scrolledWindowGetVscrollbar             ,


-- ** new #method:new#
    scrolledWindowNew                       ,


-- ** setCaptureButtonPress #method:setCaptureButtonPress#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetCaptureButtonPressMethodInfo,
#endif
    scrolledWindowSetCaptureButtonPress     ,


-- ** setHadjustment #method:setHadjustment#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetHadjustmentMethodInfo  ,
#endif
    scrolledWindowSetHadjustment            ,


-- ** setKineticScrolling #method:setKineticScrolling#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetKineticScrollingMethodInfo,
#endif
    scrolledWindowSetKineticScrolling       ,


-- ** setMaxContentHeight #method:setMaxContentHeight#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetMaxContentHeightMethodInfo,
#endif
    scrolledWindowSetMaxContentHeight       ,


-- ** setMaxContentWidth #method:setMaxContentWidth#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetMaxContentWidthMethodInfo,
#endif
    scrolledWindowSetMaxContentWidth        ,


-- ** setMinContentHeight #method:setMinContentHeight#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetMinContentHeightMethodInfo,
#endif
    scrolledWindowSetMinContentHeight       ,


-- ** setMinContentWidth #method:setMinContentWidth#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetMinContentWidthMethodInfo,
#endif
    scrolledWindowSetMinContentWidth        ,


-- ** setOverlayScrolling #method:setOverlayScrolling#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetOverlayScrollingMethodInfo,
#endif
    scrolledWindowSetOverlayScrolling       ,


-- ** setPlacement #method:setPlacement#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetPlacementMethodInfo    ,
#endif
    scrolledWindowSetPlacement              ,


-- ** setPolicy #method:setPolicy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetPolicyMethodInfo       ,
#endif
    scrolledWindowSetPolicy                 ,


-- ** setPropagateNaturalHeight #method:setPropagateNaturalHeight#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetPropagateNaturalHeightMethodInfo,
#endif
    scrolledWindowSetPropagateNaturalHeight ,


-- ** setPropagateNaturalWidth #method:setPropagateNaturalWidth#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetPropagateNaturalWidthMethodInfo,
#endif
    scrolledWindowSetPropagateNaturalWidth  ,


-- ** setShadowType #method:setShadowType#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetShadowTypeMethodInfo   ,
#endif
    scrolledWindowSetShadowType             ,


-- ** setVadjustment #method:setVadjustment#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowSetVadjustmentMethodInfo  ,
#endif
    scrolledWindowSetVadjustment            ,


-- ** unsetPlacement #method:unsetPlacement#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowUnsetPlacementMethodInfo  ,
#endif
    scrolledWindowUnsetPlacement            ,




 -- * Properties
-- ** hadjustment #attr:hadjustment#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowHadjustmentPropertyInfo   ,
#endif
    constructScrolledWindowHadjustment      ,
    getScrolledWindowHadjustment            ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowHadjustment               ,
#endif
    setScrolledWindowHadjustment            ,


-- ** hscrollbarPolicy #attr:hscrollbarPolicy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowHscrollbarPolicyPropertyInfo,
#endif
    constructScrolledWindowHscrollbarPolicy ,
    getScrolledWindowHscrollbarPolicy       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowHscrollbarPolicy          ,
#endif
    setScrolledWindowHscrollbarPolicy       ,


-- ** kineticScrolling #attr:kineticScrolling#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowKineticScrollingPropertyInfo,
#endif
    constructScrolledWindowKineticScrolling ,
    getScrolledWindowKineticScrolling       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowKineticScrolling          ,
#endif
    setScrolledWindowKineticScrolling       ,


-- ** maxContentHeight #attr:maxContentHeight#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowMaxContentHeightPropertyInfo,
#endif
    constructScrolledWindowMaxContentHeight ,
    getScrolledWindowMaxContentHeight       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowMaxContentHeight          ,
#endif
    setScrolledWindowMaxContentHeight       ,


-- ** maxContentWidth #attr:maxContentWidth#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowMaxContentWidthPropertyInfo,
#endif
    constructScrolledWindowMaxContentWidth  ,
    getScrolledWindowMaxContentWidth        ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowMaxContentWidth           ,
#endif
    setScrolledWindowMaxContentWidth        ,


-- ** minContentHeight #attr:minContentHeight#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowMinContentHeightPropertyInfo,
#endif
    constructScrolledWindowMinContentHeight ,
    getScrolledWindowMinContentHeight       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowMinContentHeight          ,
#endif
    setScrolledWindowMinContentHeight       ,


-- ** minContentWidth #attr:minContentWidth#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowMinContentWidthPropertyInfo,
#endif
    constructScrolledWindowMinContentWidth  ,
    getScrolledWindowMinContentWidth        ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowMinContentWidth           ,
#endif
    setScrolledWindowMinContentWidth        ,


-- ** overlayScrolling #attr:overlayScrolling#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowOverlayScrollingPropertyInfo,
#endif
    constructScrolledWindowOverlayScrolling ,
    getScrolledWindowOverlayScrolling       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowOverlayScrolling          ,
#endif
    setScrolledWindowOverlayScrolling       ,


-- ** propagateNaturalHeight #attr:propagateNaturalHeight#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowPropagateNaturalHeightPropertyInfo,
#endif
    constructScrolledWindowPropagateNaturalHeight,
    getScrolledWindowPropagateNaturalHeight ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowPropagateNaturalHeight    ,
#endif
    setScrolledWindowPropagateNaturalHeight ,


-- ** propagateNaturalWidth #attr:propagateNaturalWidth#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowPropagateNaturalWidthPropertyInfo,
#endif
    constructScrolledWindowPropagateNaturalWidth,
    getScrolledWindowPropagateNaturalWidth  ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowPropagateNaturalWidth     ,
#endif
    setScrolledWindowPropagateNaturalWidth  ,


-- ** shadowType #attr:shadowType#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowShadowTypePropertyInfo    ,
#endif
    constructScrolledWindowShadowType       ,
    getScrolledWindowShadowType             ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowShadowType                ,
#endif
    setScrolledWindowShadowType             ,


-- ** vadjustment #attr:vadjustment#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowVadjustmentPropertyInfo   ,
#endif
    constructScrolledWindowVadjustment      ,
    getScrolledWindowVadjustment            ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowVadjustment               ,
#endif
    setScrolledWindowVadjustment            ,


-- ** vscrollbarPolicy #attr:vscrollbarPolicy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowVscrollbarPolicyPropertyInfo,
#endif
    constructScrolledWindowVscrollbarPolicy ,
    getScrolledWindowVscrollbarPolicy       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowVscrollbarPolicy          ,
#endif
    setScrolledWindowVscrollbarPolicy       ,


-- ** windowPlacement #attr:windowPlacement#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowWindowPlacementPropertyInfo,
#endif
    constructScrolledWindowWindowPlacement  ,
    getScrolledWindowWindowPlacement        ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowWindowPlacement           ,
#endif
    setScrolledWindowWindowPlacement        ,


-- ** windowPlacementSet #attr:windowPlacementSet#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowWindowPlacementSetPropertyInfo,
#endif
    constructScrolledWindowWindowPlacementSet,
    getScrolledWindowWindowPlacementSet     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    scrolledWindowWindowPlacementSet        ,
#endif
    setScrolledWindowWindowPlacementSet     ,




 -- * Signals
-- ** edgeOvershot #signal:edgeOvershot#
    C_ScrolledWindowEdgeOvershotCallback    ,
    ScrolledWindowEdgeOvershotCallback      ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowEdgeOvershotSignalInfo    ,
#endif
    afterScrolledWindowEdgeOvershot         ,
    genClosure_ScrolledWindowEdgeOvershot   ,
    mk_ScrolledWindowEdgeOvershotCallback   ,
    noScrolledWindowEdgeOvershotCallback    ,
    onScrolledWindowEdgeOvershot            ,
    wrap_ScrolledWindowEdgeOvershotCallback ,


-- ** edgeReached #signal:edgeReached#
    C_ScrolledWindowEdgeReachedCallback     ,
    ScrolledWindowEdgeReachedCallback       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowEdgeReachedSignalInfo     ,
#endif
    afterScrolledWindowEdgeReached          ,
    genClosure_ScrolledWindowEdgeReached    ,
    mk_ScrolledWindowEdgeReachedCallback    ,
    noScrolledWindowEdgeReachedCallback     ,
    onScrolledWindowEdgeReached             ,
    wrap_ScrolledWindowEdgeReachedCallback  ,


-- ** moveFocusOut #signal:moveFocusOut#
    C_ScrolledWindowMoveFocusOutCallback    ,
    ScrolledWindowMoveFocusOutCallback      ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowMoveFocusOutSignalInfo    ,
#endif
    afterScrolledWindowMoveFocusOut         ,
    genClosure_ScrolledWindowMoveFocusOut   ,
    mk_ScrolledWindowMoveFocusOutCallback   ,
    noScrolledWindowMoveFocusOutCallback    ,
    onScrolledWindowMoveFocusOut            ,
    wrap_ScrolledWindowMoveFocusOutCallback ,


-- ** scrollChild #signal:scrollChild#
    C_ScrolledWindowScrollChildCallback     ,
    ScrolledWindowScrollChildCallback       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ScrolledWindowScrollChildSignalInfo     ,
#endif
    afterScrolledWindowScrollChild          ,
    genClosure_ScrolledWindowScrollChild    ,
    mk_ScrolledWindowScrollChildCallback    ,
    noScrolledWindowScrollChildCallback     ,
    onScrolledWindowScrollChild             ,
    wrap_ScrolledWindowScrollChildCallback  ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Objects.Adjustment as Gtk.Adjustment
import {-# SOURCE #-} qualified GI.Gtk.Objects.Bin as Gtk.Bin
import {-# SOURCE #-} qualified GI.Gtk.Objects.Container as Gtk.Container
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

newtype ScrolledWindow = ScrolledWindow (ManagedPtr ScrolledWindow)
foreign import ccall "gtk_scrolled_window_get_type"
    c_gtk_scrolled_window_get_type :: IO GType

instance GObject ScrolledWindow where
    gobjectType _ = c_gtk_scrolled_window_get_type
    

class GObject o => IsScrolledWindow o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError ScrolledWindow a) =>
    IsScrolledWindow a
#endif
instance IsScrolledWindow ScrolledWindow
instance Gtk.Bin.IsBin ScrolledWindow
instance Gtk.Container.IsContainer ScrolledWindow
instance Gtk.Widget.IsWidget ScrolledWindow
instance GObject.Object.IsObject ScrolledWindow
instance Atk.ImplementorIface.IsImplementorIface ScrolledWindow
instance Gtk.Buildable.IsBuildable ScrolledWindow

toScrolledWindow :: (MonadIO m, IsScrolledWindow o) => o -> m ScrolledWindow
toScrolledWindow = liftIO . unsafeCastTo ScrolledWindow

noScrolledWindow :: Maybe ScrolledWindow
noScrolledWindow = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveScrolledWindowMethod (t :: Symbol) (o :: *) :: * where
    ResolveScrolledWindowMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveScrolledWindowMethod "add" o = Gtk.Container.ContainerAddMethodInfo
    ResolveScrolledWindowMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
    ResolveScrolledWindowMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveScrolledWindowMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
    ResolveScrolledWindowMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
    ResolveScrolledWindowMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveScrolledWindowMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveScrolledWindowMethod "addWithViewport" o = ScrolledWindowAddWithViewportMethodInfo
    ResolveScrolledWindowMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveScrolledWindowMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveScrolledWindowMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
    ResolveScrolledWindowMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
    ResolveScrolledWindowMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveScrolledWindowMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
    ResolveScrolledWindowMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
    ResolveScrolledWindowMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
    ResolveScrolledWindowMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
    ResolveScrolledWindowMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
    ResolveScrolledWindowMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
    ResolveScrolledWindowMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveScrolledWindowMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveScrolledWindowMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveScrolledWindowMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveScrolledWindowMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveScrolledWindowMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveScrolledWindowMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveScrolledWindowMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
    ResolveScrolledWindowMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
    ResolveScrolledWindowMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
    ResolveScrolledWindowMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
    ResolveScrolledWindowMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
    ResolveScrolledWindowMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveScrolledWindowMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
    ResolveScrolledWindowMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
    ResolveScrolledWindowMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
    ResolveScrolledWindowMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
    ResolveScrolledWindowMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
    ResolveScrolledWindowMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
    ResolveScrolledWindowMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
    ResolveScrolledWindowMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
    ResolveScrolledWindowMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
    ResolveScrolledWindowMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
    ResolveScrolledWindowMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
    ResolveScrolledWindowMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
    ResolveScrolledWindowMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
    ResolveScrolledWindowMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
    ResolveScrolledWindowMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
    ResolveScrolledWindowMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
    ResolveScrolledWindowMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
    ResolveScrolledWindowMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
    ResolveScrolledWindowMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
    ResolveScrolledWindowMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
    ResolveScrolledWindowMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
    ResolveScrolledWindowMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
    ResolveScrolledWindowMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
    ResolveScrolledWindowMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
    ResolveScrolledWindowMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
    ResolveScrolledWindowMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
    ResolveScrolledWindowMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
    ResolveScrolledWindowMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveScrolledWindowMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
    ResolveScrolledWindowMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
    ResolveScrolledWindowMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveScrolledWindowMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
    ResolveScrolledWindowMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
    ResolveScrolledWindowMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveScrolledWindowMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
    ResolveScrolledWindowMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
    ResolveScrolledWindowMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveScrolledWindowMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
    ResolveScrolledWindowMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveScrolledWindowMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveScrolledWindowMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
    ResolveScrolledWindowMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
    ResolveScrolledWindowMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
    ResolveScrolledWindowMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveScrolledWindowMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveScrolledWindowMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
    ResolveScrolledWindowMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveScrolledWindowMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveScrolledWindowMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
    ResolveScrolledWindowMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveScrolledWindowMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
    ResolveScrolledWindowMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveScrolledWindowMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
    ResolveScrolledWindowMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveScrolledWindowMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveScrolledWindowMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveScrolledWindowMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveScrolledWindowMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
    ResolveScrolledWindowMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveScrolledWindowMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveScrolledWindowMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
    ResolveScrolledWindowMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
    ResolveScrolledWindowMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveScrolledWindowMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveScrolledWindowMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveScrolledWindowMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
    ResolveScrolledWindowMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
    ResolveScrolledWindowMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
    ResolveScrolledWindowMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
    ResolveScrolledWindowMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
    ResolveScrolledWindowMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
    ResolveScrolledWindowMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
    ResolveScrolledWindowMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveScrolledWindowMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveScrolledWindowMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
    ResolveScrolledWindowMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
    ResolveScrolledWindowMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
    ResolveScrolledWindowMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
    ResolveScrolledWindowMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
    ResolveScrolledWindowMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveScrolledWindowMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
    ResolveScrolledWindowMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
    ResolveScrolledWindowMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveScrolledWindowMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
    ResolveScrolledWindowMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveScrolledWindowMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
    ResolveScrolledWindowMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
    ResolveScrolledWindowMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveScrolledWindowMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
    ResolveScrolledWindowMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveScrolledWindowMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveScrolledWindowMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveScrolledWindowMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
    ResolveScrolledWindowMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
    ResolveScrolledWindowMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
    ResolveScrolledWindowMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
    ResolveScrolledWindowMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveScrolledWindowMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveScrolledWindowMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
    ResolveScrolledWindowMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
    ResolveScrolledWindowMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
    ResolveScrolledWindowMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveScrolledWindowMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveScrolledWindowMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
    ResolveScrolledWindowMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
    ResolveScrolledWindowMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
    ResolveScrolledWindowMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveScrolledWindowMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
    ResolveScrolledWindowMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
    ResolveScrolledWindowMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
    ResolveScrolledWindowMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveScrolledWindowMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
    ResolveScrolledWindowMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
    ResolveScrolledWindowMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveScrolledWindowMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
    ResolveScrolledWindowMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
    ResolveScrolledWindowMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveScrolledWindowMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveScrolledWindowMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
    ResolveScrolledWindowMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
    ResolveScrolledWindowMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
    ResolveScrolledWindowMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveScrolledWindowMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveScrolledWindowMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveScrolledWindowMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveScrolledWindowMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveScrolledWindowMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveScrolledWindowMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveScrolledWindowMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
    ResolveScrolledWindowMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
    ResolveScrolledWindowMethod "unsetPlacement" o = ScrolledWindowUnsetPlacementMethodInfo
    ResolveScrolledWindowMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveScrolledWindowMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveScrolledWindowMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
    ResolveScrolledWindowMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
    ResolveScrolledWindowMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveScrolledWindowMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveScrolledWindowMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
    ResolveScrolledWindowMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveScrolledWindowMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveScrolledWindowMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveScrolledWindowMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveScrolledWindowMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
    ResolveScrolledWindowMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveScrolledWindowMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveScrolledWindowMethod "getCaptureButtonPress" o = ScrolledWindowGetCaptureButtonPressMethodInfo
    ResolveScrolledWindowMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo
    ResolveScrolledWindowMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
    ResolveScrolledWindowMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveScrolledWindowMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
    ResolveScrolledWindowMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
    ResolveScrolledWindowMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveScrolledWindowMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
    ResolveScrolledWindowMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveScrolledWindowMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
    ResolveScrolledWindowMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
    ResolveScrolledWindowMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveScrolledWindowMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveScrolledWindowMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
    ResolveScrolledWindowMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
    ResolveScrolledWindowMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
    ResolveScrolledWindowMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
    ResolveScrolledWindowMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
    ResolveScrolledWindowMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveScrolledWindowMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
    ResolveScrolledWindowMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveScrolledWindowMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveScrolledWindowMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveScrolledWindowMethod "getHadjustment" o = ScrolledWindowGetHadjustmentMethodInfo
    ResolveScrolledWindowMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveScrolledWindowMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveScrolledWindowMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
    ResolveScrolledWindowMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveScrolledWindowMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveScrolledWindowMethod "getHscrollbar" o = ScrolledWindowGetHscrollbarMethodInfo
    ResolveScrolledWindowMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveScrolledWindowMethod "getKineticScrolling" o = ScrolledWindowGetKineticScrollingMethodInfo
    ResolveScrolledWindowMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveScrolledWindowMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveScrolledWindowMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveScrolledWindowMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
    ResolveScrolledWindowMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
    ResolveScrolledWindowMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveScrolledWindowMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveScrolledWindowMethod "getMaxContentHeight" o = ScrolledWindowGetMaxContentHeightMethodInfo
    ResolveScrolledWindowMethod "getMaxContentWidth" o = ScrolledWindowGetMaxContentWidthMethodInfo
    ResolveScrolledWindowMethod "getMinContentHeight" o = ScrolledWindowGetMinContentHeightMethodInfo
    ResolveScrolledWindowMethod "getMinContentWidth" o = ScrolledWindowGetMinContentWidthMethodInfo
    ResolveScrolledWindowMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
    ResolveScrolledWindowMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
    ResolveScrolledWindowMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveScrolledWindowMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
    ResolveScrolledWindowMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveScrolledWindowMethod "getOverlayScrolling" o = ScrolledWindowGetOverlayScrollingMethodInfo
    ResolveScrolledWindowMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveScrolledWindowMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveScrolledWindowMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
    ResolveScrolledWindowMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
    ResolveScrolledWindowMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
    ResolveScrolledWindowMethod "getPlacement" o = ScrolledWindowGetPlacementMethodInfo
    ResolveScrolledWindowMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
    ResolveScrolledWindowMethod "getPolicy" o = ScrolledWindowGetPolicyMethodInfo
    ResolveScrolledWindowMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
    ResolveScrolledWindowMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveScrolledWindowMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
    ResolveScrolledWindowMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveScrolledWindowMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
    ResolveScrolledWindowMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
    ResolveScrolledWindowMethod "getPropagateNaturalHeight" o = ScrolledWindowGetPropagateNaturalHeightMethodInfo
    ResolveScrolledWindowMethod "getPropagateNaturalWidth" o = ScrolledWindowGetPropagateNaturalWidthMethodInfo
    ResolveScrolledWindowMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveScrolledWindowMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveScrolledWindowMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveScrolledWindowMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveScrolledWindowMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveScrolledWindowMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
    ResolveScrolledWindowMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
    ResolveScrolledWindowMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
    ResolveScrolledWindowMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveScrolledWindowMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
    ResolveScrolledWindowMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveScrolledWindowMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveScrolledWindowMethod "getShadowType" o = ScrolledWindowGetShadowTypeMethodInfo
    ResolveScrolledWindowMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveScrolledWindowMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
    ResolveScrolledWindowMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveScrolledWindowMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
    ResolveScrolledWindowMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveScrolledWindowMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
    ResolveScrolledWindowMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveScrolledWindowMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveScrolledWindowMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveScrolledWindowMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
    ResolveScrolledWindowMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
    ResolveScrolledWindowMethod "getVadjustment" o = ScrolledWindowGetVadjustmentMethodInfo
    ResolveScrolledWindowMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveScrolledWindowMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
    ResolveScrolledWindowMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveScrolledWindowMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveScrolledWindowMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveScrolledWindowMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
    ResolveScrolledWindowMethod "getVscrollbar" o = ScrolledWindowGetVscrollbarMethodInfo
    ResolveScrolledWindowMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
    ResolveScrolledWindowMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
    ResolveScrolledWindowMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
    ResolveScrolledWindowMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveScrolledWindowMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
    ResolveScrolledWindowMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveScrolledWindowMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveScrolledWindowMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveScrolledWindowMethod "setCaptureButtonPress" o = ScrolledWindowSetCaptureButtonPressMethodInfo
    ResolveScrolledWindowMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveScrolledWindowMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
    ResolveScrolledWindowMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
    ResolveScrolledWindowMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveScrolledWindowMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
    ResolveScrolledWindowMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
    ResolveScrolledWindowMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveScrolledWindowMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
    ResolveScrolledWindowMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
    ResolveScrolledWindowMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
    ResolveScrolledWindowMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
    ResolveScrolledWindowMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
    ResolveScrolledWindowMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveScrolledWindowMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
    ResolveScrolledWindowMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveScrolledWindowMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveScrolledWindowMethod "setHadjustment" o = ScrolledWindowSetHadjustmentMethodInfo
    ResolveScrolledWindowMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveScrolledWindowMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveScrolledWindowMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
    ResolveScrolledWindowMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveScrolledWindowMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveScrolledWindowMethod "setKineticScrolling" o = ScrolledWindowSetKineticScrollingMethodInfo
    ResolveScrolledWindowMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
    ResolveScrolledWindowMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveScrolledWindowMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveScrolledWindowMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
    ResolveScrolledWindowMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
    ResolveScrolledWindowMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveScrolledWindowMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveScrolledWindowMethod "setMaxContentHeight" o = ScrolledWindowSetMaxContentHeightMethodInfo
    ResolveScrolledWindowMethod "setMaxContentWidth" o = ScrolledWindowSetMaxContentWidthMethodInfo
    ResolveScrolledWindowMethod "setMinContentHeight" o = ScrolledWindowSetMinContentHeightMethodInfo
    ResolveScrolledWindowMethod "setMinContentWidth" o = ScrolledWindowSetMinContentWidthMethodInfo
    ResolveScrolledWindowMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveScrolledWindowMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
    ResolveScrolledWindowMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveScrolledWindowMethod "setOverlayScrolling" o = ScrolledWindowSetOverlayScrollingMethodInfo
    ResolveScrolledWindowMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveScrolledWindowMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
    ResolveScrolledWindowMethod "setPlacement" o = ScrolledWindowSetPlacementMethodInfo
    ResolveScrolledWindowMethod "setPolicy" o = ScrolledWindowSetPolicyMethodInfo
    ResolveScrolledWindowMethod "setPropagateNaturalHeight" o = ScrolledWindowSetPropagateNaturalHeightMethodInfo
    ResolveScrolledWindowMethod "setPropagateNaturalWidth" o = ScrolledWindowSetPropagateNaturalWidthMethodInfo
    ResolveScrolledWindowMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveScrolledWindowMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
    ResolveScrolledWindowMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
    ResolveScrolledWindowMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveScrolledWindowMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
    ResolveScrolledWindowMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
    ResolveScrolledWindowMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveScrolledWindowMethod "setShadowType" o = ScrolledWindowSetShadowTypeMethodInfo
    ResolveScrolledWindowMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveScrolledWindowMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
    ResolveScrolledWindowMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveScrolledWindowMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
    ResolveScrolledWindowMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
    ResolveScrolledWindowMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveScrolledWindowMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveScrolledWindowMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
    ResolveScrolledWindowMethod "setVadjustment" o = ScrolledWindowSetVadjustmentMethodInfo
    ResolveScrolledWindowMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveScrolledWindowMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveScrolledWindowMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveScrolledWindowMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveScrolledWindowMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
    ResolveScrolledWindowMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
    ResolveScrolledWindowMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveScrolledWindowMethod t ScrolledWindow, O.MethodInfo info ScrolledWindow p) => O.IsLabelProxy t (ScrolledWindow -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveScrolledWindowMethod t ScrolledWindow, O.MethodInfo info ScrolledWindow p) => O.IsLabel t (ScrolledWindow -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif

-- signal ScrolledWindow::edge-overshot
type ScrolledWindowEdgeOvershotCallback =
    Gtk.Enums.PositionType ->
    IO ()

noScrolledWindowEdgeOvershotCallback :: Maybe ScrolledWindowEdgeOvershotCallback
noScrolledWindowEdgeOvershotCallback = Nothing

type C_ScrolledWindowEdgeOvershotCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_ScrolledWindowEdgeOvershotCallback :: C_ScrolledWindowEdgeOvershotCallback -> IO (FunPtr C_ScrolledWindowEdgeOvershotCallback)

genClosure_ScrolledWindowEdgeOvershot :: ScrolledWindowEdgeOvershotCallback -> IO Closure
genClosure_ScrolledWindowEdgeOvershot cb = do
    let cb' = wrap_ScrolledWindowEdgeOvershotCallback cb
    mk_ScrolledWindowEdgeOvershotCallback cb' >>= newCClosure


wrap_ScrolledWindowEdgeOvershotCallback ::
    ScrolledWindowEdgeOvershotCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO ()
wrap_ScrolledWindowEdgeOvershotCallback _cb _ pos _ = do
    let pos' = (toEnum . fromIntegral) pos
    _cb  pos'


onScrolledWindowEdgeOvershot :: (IsScrolledWindow a, MonadIO m) => a -> ScrolledWindowEdgeOvershotCallback -> m SignalHandlerId
onScrolledWindowEdgeOvershot obj cb = liftIO $ do
    let cb' = wrap_ScrolledWindowEdgeOvershotCallback cb
    cb'' <- mk_ScrolledWindowEdgeOvershotCallback cb'
    connectSignalFunPtr obj "edge-overshot" cb'' SignalConnectBefore

afterScrolledWindowEdgeOvershot :: (IsScrolledWindow a, MonadIO m) => a -> ScrolledWindowEdgeOvershotCallback -> m SignalHandlerId
afterScrolledWindowEdgeOvershot obj cb = liftIO $ do
    let cb' = wrap_ScrolledWindowEdgeOvershotCallback cb
    cb'' <- mk_ScrolledWindowEdgeOvershotCallback cb'
    connectSignalFunPtr obj "edge-overshot" cb'' SignalConnectAfter


-- signal ScrolledWindow::edge-reached
type ScrolledWindowEdgeReachedCallback =
    Gtk.Enums.PositionType ->
    IO ()

noScrolledWindowEdgeReachedCallback :: Maybe ScrolledWindowEdgeReachedCallback
noScrolledWindowEdgeReachedCallback = Nothing

type C_ScrolledWindowEdgeReachedCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_ScrolledWindowEdgeReachedCallback :: C_ScrolledWindowEdgeReachedCallback -> IO (FunPtr C_ScrolledWindowEdgeReachedCallback)

genClosure_ScrolledWindowEdgeReached :: ScrolledWindowEdgeReachedCallback -> IO Closure
genClosure_ScrolledWindowEdgeReached cb = do
    let cb' = wrap_ScrolledWindowEdgeReachedCallback cb
    mk_ScrolledWindowEdgeReachedCallback cb' >>= newCClosure


wrap_ScrolledWindowEdgeReachedCallback ::
    ScrolledWindowEdgeReachedCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO ()
wrap_ScrolledWindowEdgeReachedCallback _cb _ pos _ = do
    let pos' = (toEnum . fromIntegral) pos
    _cb  pos'


onScrolledWindowEdgeReached :: (IsScrolledWindow a, MonadIO m) => a -> ScrolledWindowEdgeReachedCallback -> m SignalHandlerId
onScrolledWindowEdgeReached obj cb = liftIO $ do
    let cb' = wrap_ScrolledWindowEdgeReachedCallback cb
    cb'' <- mk_ScrolledWindowEdgeReachedCallback cb'
    connectSignalFunPtr obj "edge-reached" cb'' SignalConnectBefore

afterScrolledWindowEdgeReached :: (IsScrolledWindow a, MonadIO m) => a -> ScrolledWindowEdgeReachedCallback -> m SignalHandlerId
afterScrolledWindowEdgeReached obj cb = liftIO $ do
    let cb' = wrap_ScrolledWindowEdgeReachedCallback cb
    cb'' <- mk_ScrolledWindowEdgeReachedCallback cb'
    connectSignalFunPtr obj "edge-reached" cb'' SignalConnectAfter


-- signal ScrolledWindow::move-focus-out
type ScrolledWindowMoveFocusOutCallback =
    Gtk.Enums.DirectionType ->
    IO ()

noScrolledWindowMoveFocusOutCallback :: Maybe ScrolledWindowMoveFocusOutCallback
noScrolledWindowMoveFocusOutCallback = Nothing

type C_ScrolledWindowMoveFocusOutCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_ScrolledWindowMoveFocusOutCallback :: C_ScrolledWindowMoveFocusOutCallback -> IO (FunPtr C_ScrolledWindowMoveFocusOutCallback)

genClosure_ScrolledWindowMoveFocusOut :: ScrolledWindowMoveFocusOutCallback -> IO Closure
genClosure_ScrolledWindowMoveFocusOut cb = do
    let cb' = wrap_ScrolledWindowMoveFocusOutCallback cb
    mk_ScrolledWindowMoveFocusOutCallback cb' >>= newCClosure


wrap_ScrolledWindowMoveFocusOutCallback ::
    ScrolledWindowMoveFocusOutCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO ()
wrap_ScrolledWindowMoveFocusOutCallback _cb _ directionType _ = do
    let directionType' = (toEnum . fromIntegral) directionType
    _cb  directionType'


onScrolledWindowMoveFocusOut :: (IsScrolledWindow a, MonadIO m) => a -> ScrolledWindowMoveFocusOutCallback -> m SignalHandlerId
onScrolledWindowMoveFocusOut obj cb = liftIO $ do
    let cb' = wrap_ScrolledWindowMoveFocusOutCallback cb
    cb'' <- mk_ScrolledWindowMoveFocusOutCallback cb'
    connectSignalFunPtr obj "move-focus-out" cb'' SignalConnectBefore

afterScrolledWindowMoveFocusOut :: (IsScrolledWindow a, MonadIO m) => a -> ScrolledWindowMoveFocusOutCallback -> m SignalHandlerId
afterScrolledWindowMoveFocusOut obj cb = liftIO $ do
    let cb' = wrap_ScrolledWindowMoveFocusOutCallback cb
    cb'' <- mk_ScrolledWindowMoveFocusOutCallback cb'
    connectSignalFunPtr obj "move-focus-out" cb'' SignalConnectAfter


-- signal ScrolledWindow::scroll-child
type ScrolledWindowScrollChildCallback =
    Gtk.Enums.ScrollType ->
    Bool ->
    IO Bool

noScrolledWindowScrollChildCallback :: Maybe ScrolledWindowScrollChildCallback
noScrolledWindowScrollChildCallback = Nothing

type C_ScrolledWindowScrollChildCallback =
    Ptr () ->                               -- object
    CUInt ->
    CInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_ScrolledWindowScrollChildCallback :: C_ScrolledWindowScrollChildCallback -> IO (FunPtr C_ScrolledWindowScrollChildCallback)

genClosure_ScrolledWindowScrollChild :: ScrolledWindowScrollChildCallback -> IO Closure
genClosure_ScrolledWindowScrollChild cb = do
    let cb' = wrap_ScrolledWindowScrollChildCallback cb
    mk_ScrolledWindowScrollChildCallback cb' >>= newCClosure


wrap_ScrolledWindowScrollChildCallback ::
    ScrolledWindowScrollChildCallback ->
    Ptr () ->
    CUInt ->
    CInt ->
    Ptr () ->
    IO CInt
wrap_ScrolledWindowScrollChildCallback _cb _ scroll horizontal _ = do
    let scroll' = (toEnum . fromIntegral) scroll
    let horizontal' = (/= 0) horizontal
    result <- _cb  scroll' horizontal'
    let result' = (fromIntegral . fromEnum) result
    return result'


onScrolledWindowScrollChild :: (IsScrolledWindow a, MonadIO m) => a -> ScrolledWindowScrollChildCallback -> m SignalHandlerId
onScrolledWindowScrollChild obj cb = liftIO $ do
    let cb' = wrap_ScrolledWindowScrollChildCallback cb
    cb'' <- mk_ScrolledWindowScrollChildCallback cb'
    connectSignalFunPtr obj "scroll-child" cb'' SignalConnectBefore

afterScrolledWindowScrollChild :: (IsScrolledWindow a, MonadIO m) => a -> ScrolledWindowScrollChildCallback -> m SignalHandlerId
afterScrolledWindowScrollChild obj cb = liftIO $ do
    let cb' = wrap_ScrolledWindowScrollChildCallback cb
    cb'' <- mk_ScrolledWindowScrollChildCallback cb'
    connectSignalFunPtr obj "scroll-child" cb'' SignalConnectAfter


-- VVV Prop "hadjustment"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Adjustment"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

getScrolledWindowHadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m Gtk.Adjustment.Adjustment
getScrolledWindowHadjustment obj = liftIO $ checkUnexpectedNothing "getScrolledWindowHadjustment" $ getObjectPropertyObject obj "hadjustment" Gtk.Adjustment.Adjustment

setScrolledWindowHadjustment :: (MonadIO m, IsScrolledWindow o, Gtk.Adjustment.IsAdjustment a) => o -> a -> m ()
setScrolledWindowHadjustment obj val = liftIO $ setObjectPropertyObject obj "hadjustment" (Just val)

constructScrolledWindowHadjustment :: (IsScrolledWindow o, Gtk.Adjustment.IsAdjustment a) => a -> IO (GValueConstruct o)
constructScrolledWindowHadjustment val = constructObjectPropertyObject "hadjustment" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowHadjustmentPropertyInfo
instance AttrInfo ScrolledWindowHadjustmentPropertyInfo where
    type AttrAllowedOps ScrolledWindowHadjustmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowHadjustmentPropertyInfo = Gtk.Adjustment.IsAdjustment
    type AttrBaseTypeConstraint ScrolledWindowHadjustmentPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowHadjustmentPropertyInfo = Gtk.Adjustment.Adjustment
    type AttrLabel ScrolledWindowHadjustmentPropertyInfo = "hadjustment"
    type AttrOrigin ScrolledWindowHadjustmentPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowHadjustment
    attrSet _ = setScrolledWindowHadjustment
    attrConstruct _ = constructScrolledWindowHadjustment
    attrClear _ = undefined
#endif

-- VVV Prop "hscrollbar-policy"
   -- Type: TInterface (Name {namespace = "Gtk", name = "PolicyType"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getScrolledWindowHscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> m Gtk.Enums.PolicyType
getScrolledWindowHscrollbarPolicy obj = liftIO $ getObjectPropertyEnum obj "hscrollbar-policy"

setScrolledWindowHscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> Gtk.Enums.PolicyType -> m ()
setScrolledWindowHscrollbarPolicy obj val = liftIO $ setObjectPropertyEnum obj "hscrollbar-policy" val

constructScrolledWindowHscrollbarPolicy :: (IsScrolledWindow o) => Gtk.Enums.PolicyType -> IO (GValueConstruct o)
constructScrolledWindowHscrollbarPolicy val = constructObjectPropertyEnum "hscrollbar-policy" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowHscrollbarPolicyPropertyInfo
instance AttrInfo ScrolledWindowHscrollbarPolicyPropertyInfo where
    type AttrAllowedOps ScrolledWindowHscrollbarPolicyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowHscrollbarPolicyPropertyInfo = (~) Gtk.Enums.PolicyType
    type AttrBaseTypeConstraint ScrolledWindowHscrollbarPolicyPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowHscrollbarPolicyPropertyInfo = Gtk.Enums.PolicyType
    type AttrLabel ScrolledWindowHscrollbarPolicyPropertyInfo = "hscrollbar-policy"
    type AttrOrigin ScrolledWindowHscrollbarPolicyPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowHscrollbarPolicy
    attrSet _ = setScrolledWindowHscrollbarPolicy
    attrConstruct _ = constructScrolledWindowHscrollbarPolicy
    attrClear _ = undefined
#endif

-- VVV Prop "kinetic-scrolling"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getScrolledWindowKineticScrolling :: (MonadIO m, IsScrolledWindow o) => o -> m Bool
getScrolledWindowKineticScrolling obj = liftIO $ getObjectPropertyBool obj "kinetic-scrolling"

setScrolledWindowKineticScrolling :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()
setScrolledWindowKineticScrolling obj val = liftIO $ setObjectPropertyBool obj "kinetic-scrolling" val

constructScrolledWindowKineticScrolling :: (IsScrolledWindow o) => Bool -> IO (GValueConstruct o)
constructScrolledWindowKineticScrolling val = constructObjectPropertyBool "kinetic-scrolling" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowKineticScrollingPropertyInfo
instance AttrInfo ScrolledWindowKineticScrollingPropertyInfo where
    type AttrAllowedOps ScrolledWindowKineticScrollingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowKineticScrollingPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ScrolledWindowKineticScrollingPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowKineticScrollingPropertyInfo = Bool
    type AttrLabel ScrolledWindowKineticScrollingPropertyInfo = "kinetic-scrolling"
    type AttrOrigin ScrolledWindowKineticScrollingPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowKineticScrolling
    attrSet _ = setScrolledWindowKineticScrolling
    attrConstruct _ = constructScrolledWindowKineticScrolling
    attrClear _ = undefined
#endif

-- VVV Prop "max-content-height"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getScrolledWindowMaxContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> m Int32
getScrolledWindowMaxContentHeight obj = liftIO $ getObjectPropertyInt32 obj "max-content-height"

setScrolledWindowMaxContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()
setScrolledWindowMaxContentHeight obj val = liftIO $ setObjectPropertyInt32 obj "max-content-height" val

constructScrolledWindowMaxContentHeight :: (IsScrolledWindow o) => Int32 -> IO (GValueConstruct o)
constructScrolledWindowMaxContentHeight val = constructObjectPropertyInt32 "max-content-height" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowMaxContentHeightPropertyInfo
instance AttrInfo ScrolledWindowMaxContentHeightPropertyInfo where
    type AttrAllowedOps ScrolledWindowMaxContentHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowMaxContentHeightPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint ScrolledWindowMaxContentHeightPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowMaxContentHeightPropertyInfo = Int32
    type AttrLabel ScrolledWindowMaxContentHeightPropertyInfo = "max-content-height"
    type AttrOrigin ScrolledWindowMaxContentHeightPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowMaxContentHeight
    attrSet _ = setScrolledWindowMaxContentHeight
    attrConstruct _ = constructScrolledWindowMaxContentHeight
    attrClear _ = undefined
#endif

-- VVV Prop "max-content-width"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getScrolledWindowMaxContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> m Int32
getScrolledWindowMaxContentWidth obj = liftIO $ getObjectPropertyInt32 obj "max-content-width"

setScrolledWindowMaxContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()
setScrolledWindowMaxContentWidth obj val = liftIO $ setObjectPropertyInt32 obj "max-content-width" val

constructScrolledWindowMaxContentWidth :: (IsScrolledWindow o) => Int32 -> IO (GValueConstruct o)
constructScrolledWindowMaxContentWidth val = constructObjectPropertyInt32 "max-content-width" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowMaxContentWidthPropertyInfo
instance AttrInfo ScrolledWindowMaxContentWidthPropertyInfo where
    type AttrAllowedOps ScrolledWindowMaxContentWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowMaxContentWidthPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint ScrolledWindowMaxContentWidthPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowMaxContentWidthPropertyInfo = Int32
    type AttrLabel ScrolledWindowMaxContentWidthPropertyInfo = "max-content-width"
    type AttrOrigin ScrolledWindowMaxContentWidthPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowMaxContentWidth
    attrSet _ = setScrolledWindowMaxContentWidth
    attrConstruct _ = constructScrolledWindowMaxContentWidth
    attrClear _ = undefined
#endif

-- VVV Prop "min-content-height"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getScrolledWindowMinContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> m Int32
getScrolledWindowMinContentHeight obj = liftIO $ getObjectPropertyInt32 obj "min-content-height"

setScrolledWindowMinContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()
setScrolledWindowMinContentHeight obj val = liftIO $ setObjectPropertyInt32 obj "min-content-height" val

constructScrolledWindowMinContentHeight :: (IsScrolledWindow o) => Int32 -> IO (GValueConstruct o)
constructScrolledWindowMinContentHeight val = constructObjectPropertyInt32 "min-content-height" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowMinContentHeightPropertyInfo
instance AttrInfo ScrolledWindowMinContentHeightPropertyInfo where
    type AttrAllowedOps ScrolledWindowMinContentHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowMinContentHeightPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint ScrolledWindowMinContentHeightPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowMinContentHeightPropertyInfo = Int32
    type AttrLabel ScrolledWindowMinContentHeightPropertyInfo = "min-content-height"
    type AttrOrigin ScrolledWindowMinContentHeightPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowMinContentHeight
    attrSet _ = setScrolledWindowMinContentHeight
    attrConstruct _ = constructScrolledWindowMinContentHeight
    attrClear _ = undefined
#endif

-- VVV Prop "min-content-width"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getScrolledWindowMinContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> m Int32
getScrolledWindowMinContentWidth obj = liftIO $ getObjectPropertyInt32 obj "min-content-width"

setScrolledWindowMinContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()
setScrolledWindowMinContentWidth obj val = liftIO $ setObjectPropertyInt32 obj "min-content-width" val

constructScrolledWindowMinContentWidth :: (IsScrolledWindow o) => Int32 -> IO (GValueConstruct o)
constructScrolledWindowMinContentWidth val = constructObjectPropertyInt32 "min-content-width" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowMinContentWidthPropertyInfo
instance AttrInfo ScrolledWindowMinContentWidthPropertyInfo where
    type AttrAllowedOps ScrolledWindowMinContentWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowMinContentWidthPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint ScrolledWindowMinContentWidthPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowMinContentWidthPropertyInfo = Int32
    type AttrLabel ScrolledWindowMinContentWidthPropertyInfo = "min-content-width"
    type AttrOrigin ScrolledWindowMinContentWidthPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowMinContentWidth
    attrSet _ = setScrolledWindowMinContentWidth
    attrConstruct _ = constructScrolledWindowMinContentWidth
    attrClear _ = undefined
#endif

-- VVV Prop "overlay-scrolling"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getScrolledWindowOverlayScrolling :: (MonadIO m, IsScrolledWindow o) => o -> m Bool
getScrolledWindowOverlayScrolling obj = liftIO $ getObjectPropertyBool obj "overlay-scrolling"

setScrolledWindowOverlayScrolling :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()
setScrolledWindowOverlayScrolling obj val = liftIO $ setObjectPropertyBool obj "overlay-scrolling" val

constructScrolledWindowOverlayScrolling :: (IsScrolledWindow o) => Bool -> IO (GValueConstruct o)
constructScrolledWindowOverlayScrolling val = constructObjectPropertyBool "overlay-scrolling" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowOverlayScrollingPropertyInfo
instance AttrInfo ScrolledWindowOverlayScrollingPropertyInfo where
    type AttrAllowedOps ScrolledWindowOverlayScrollingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowOverlayScrollingPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ScrolledWindowOverlayScrollingPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowOverlayScrollingPropertyInfo = Bool
    type AttrLabel ScrolledWindowOverlayScrollingPropertyInfo = "overlay-scrolling"
    type AttrOrigin ScrolledWindowOverlayScrollingPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowOverlayScrolling
    attrSet _ = setScrolledWindowOverlayScrolling
    attrConstruct _ = constructScrolledWindowOverlayScrolling
    attrClear _ = undefined
#endif

-- VVV Prop "propagate-natural-height"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getScrolledWindowPropagateNaturalHeight :: (MonadIO m, IsScrolledWindow o) => o -> m Bool
getScrolledWindowPropagateNaturalHeight obj = liftIO $ getObjectPropertyBool obj "propagate-natural-height"

setScrolledWindowPropagateNaturalHeight :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()
setScrolledWindowPropagateNaturalHeight obj val = liftIO $ setObjectPropertyBool obj "propagate-natural-height" val

constructScrolledWindowPropagateNaturalHeight :: (IsScrolledWindow o) => Bool -> IO (GValueConstruct o)
constructScrolledWindowPropagateNaturalHeight val = constructObjectPropertyBool "propagate-natural-height" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowPropagateNaturalHeightPropertyInfo
instance AttrInfo ScrolledWindowPropagateNaturalHeightPropertyInfo where
    type AttrAllowedOps ScrolledWindowPropagateNaturalHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowPropagateNaturalHeightPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ScrolledWindowPropagateNaturalHeightPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowPropagateNaturalHeightPropertyInfo = Bool
    type AttrLabel ScrolledWindowPropagateNaturalHeightPropertyInfo = "propagate-natural-height"
    type AttrOrigin ScrolledWindowPropagateNaturalHeightPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowPropagateNaturalHeight
    attrSet _ = setScrolledWindowPropagateNaturalHeight
    attrConstruct _ = constructScrolledWindowPropagateNaturalHeight
    attrClear _ = undefined
#endif

-- VVV Prop "propagate-natural-width"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getScrolledWindowPropagateNaturalWidth :: (MonadIO m, IsScrolledWindow o) => o -> m Bool
getScrolledWindowPropagateNaturalWidth obj = liftIO $ getObjectPropertyBool obj "propagate-natural-width"

setScrolledWindowPropagateNaturalWidth :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()
setScrolledWindowPropagateNaturalWidth obj val = liftIO $ setObjectPropertyBool obj "propagate-natural-width" val

constructScrolledWindowPropagateNaturalWidth :: (IsScrolledWindow o) => Bool -> IO (GValueConstruct o)
constructScrolledWindowPropagateNaturalWidth val = constructObjectPropertyBool "propagate-natural-width" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowPropagateNaturalWidthPropertyInfo
instance AttrInfo ScrolledWindowPropagateNaturalWidthPropertyInfo where
    type AttrAllowedOps ScrolledWindowPropagateNaturalWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowPropagateNaturalWidthPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ScrolledWindowPropagateNaturalWidthPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowPropagateNaturalWidthPropertyInfo = Bool
    type AttrLabel ScrolledWindowPropagateNaturalWidthPropertyInfo = "propagate-natural-width"
    type AttrOrigin ScrolledWindowPropagateNaturalWidthPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowPropagateNaturalWidth
    attrSet _ = setScrolledWindowPropagateNaturalWidth
    attrConstruct _ = constructScrolledWindowPropagateNaturalWidth
    attrClear _ = undefined
#endif

-- VVV Prop "shadow-type"
   -- Type: TInterface (Name {namespace = "Gtk", name = "ShadowType"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getScrolledWindowShadowType :: (MonadIO m, IsScrolledWindow o) => o -> m Gtk.Enums.ShadowType
getScrolledWindowShadowType obj = liftIO $ getObjectPropertyEnum obj "shadow-type"

setScrolledWindowShadowType :: (MonadIO m, IsScrolledWindow o) => o -> Gtk.Enums.ShadowType -> m ()
setScrolledWindowShadowType obj val = liftIO $ setObjectPropertyEnum obj "shadow-type" val

constructScrolledWindowShadowType :: (IsScrolledWindow o) => Gtk.Enums.ShadowType -> IO (GValueConstruct o)
constructScrolledWindowShadowType val = constructObjectPropertyEnum "shadow-type" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowShadowTypePropertyInfo
instance AttrInfo ScrolledWindowShadowTypePropertyInfo where
    type AttrAllowedOps ScrolledWindowShadowTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowShadowTypePropertyInfo = (~) Gtk.Enums.ShadowType
    type AttrBaseTypeConstraint ScrolledWindowShadowTypePropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowShadowTypePropertyInfo = Gtk.Enums.ShadowType
    type AttrLabel ScrolledWindowShadowTypePropertyInfo = "shadow-type"
    type AttrOrigin ScrolledWindowShadowTypePropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowShadowType
    attrSet _ = setScrolledWindowShadowType
    attrConstruct _ = constructScrolledWindowShadowType
    attrClear _ = undefined
#endif

-- VVV Prop "vadjustment"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Adjustment"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

getScrolledWindowVadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m Gtk.Adjustment.Adjustment
getScrolledWindowVadjustment obj = liftIO $ checkUnexpectedNothing "getScrolledWindowVadjustment" $ getObjectPropertyObject obj "vadjustment" Gtk.Adjustment.Adjustment

setScrolledWindowVadjustment :: (MonadIO m, IsScrolledWindow o, Gtk.Adjustment.IsAdjustment a) => o -> a -> m ()
setScrolledWindowVadjustment obj val = liftIO $ setObjectPropertyObject obj "vadjustment" (Just val)

constructScrolledWindowVadjustment :: (IsScrolledWindow o, Gtk.Adjustment.IsAdjustment a) => a -> IO (GValueConstruct o)
constructScrolledWindowVadjustment val = constructObjectPropertyObject "vadjustment" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowVadjustmentPropertyInfo
instance AttrInfo ScrolledWindowVadjustmentPropertyInfo where
    type AttrAllowedOps ScrolledWindowVadjustmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowVadjustmentPropertyInfo = Gtk.Adjustment.IsAdjustment
    type AttrBaseTypeConstraint ScrolledWindowVadjustmentPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowVadjustmentPropertyInfo = Gtk.Adjustment.Adjustment
    type AttrLabel ScrolledWindowVadjustmentPropertyInfo = "vadjustment"
    type AttrOrigin ScrolledWindowVadjustmentPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowVadjustment
    attrSet _ = setScrolledWindowVadjustment
    attrConstruct _ = constructScrolledWindowVadjustment
    attrClear _ = undefined
#endif

-- VVV Prop "vscrollbar-policy"
   -- Type: TInterface (Name {namespace = "Gtk", name = "PolicyType"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getScrolledWindowVscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> m Gtk.Enums.PolicyType
getScrolledWindowVscrollbarPolicy obj = liftIO $ getObjectPropertyEnum obj "vscrollbar-policy"

setScrolledWindowVscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> Gtk.Enums.PolicyType -> m ()
setScrolledWindowVscrollbarPolicy obj val = liftIO $ setObjectPropertyEnum obj "vscrollbar-policy" val

constructScrolledWindowVscrollbarPolicy :: (IsScrolledWindow o) => Gtk.Enums.PolicyType -> IO (GValueConstruct o)
constructScrolledWindowVscrollbarPolicy val = constructObjectPropertyEnum "vscrollbar-policy" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowVscrollbarPolicyPropertyInfo
instance AttrInfo ScrolledWindowVscrollbarPolicyPropertyInfo where
    type AttrAllowedOps ScrolledWindowVscrollbarPolicyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowVscrollbarPolicyPropertyInfo = (~) Gtk.Enums.PolicyType
    type AttrBaseTypeConstraint ScrolledWindowVscrollbarPolicyPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowVscrollbarPolicyPropertyInfo = Gtk.Enums.PolicyType
    type AttrLabel ScrolledWindowVscrollbarPolicyPropertyInfo = "vscrollbar-policy"
    type AttrOrigin ScrolledWindowVscrollbarPolicyPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowVscrollbarPolicy
    attrSet _ = setScrolledWindowVscrollbarPolicy
    attrConstruct _ = constructScrolledWindowVscrollbarPolicy
    attrClear _ = undefined
#endif

-- VVV Prop "window-placement"
   -- Type: TInterface (Name {namespace = "Gtk", name = "CornerType"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getScrolledWindowWindowPlacement :: (MonadIO m, IsScrolledWindow o) => o -> m Gtk.Enums.CornerType
getScrolledWindowWindowPlacement obj = liftIO $ getObjectPropertyEnum obj "window-placement"

setScrolledWindowWindowPlacement :: (MonadIO m, IsScrolledWindow o) => o -> Gtk.Enums.CornerType -> m ()
setScrolledWindowWindowPlacement obj val = liftIO $ setObjectPropertyEnum obj "window-placement" val

constructScrolledWindowWindowPlacement :: (IsScrolledWindow o) => Gtk.Enums.CornerType -> IO (GValueConstruct o)
constructScrolledWindowWindowPlacement val = constructObjectPropertyEnum "window-placement" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowWindowPlacementPropertyInfo
instance AttrInfo ScrolledWindowWindowPlacementPropertyInfo where
    type AttrAllowedOps ScrolledWindowWindowPlacementPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowWindowPlacementPropertyInfo = (~) Gtk.Enums.CornerType
    type AttrBaseTypeConstraint ScrolledWindowWindowPlacementPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowWindowPlacementPropertyInfo = Gtk.Enums.CornerType
    type AttrLabel ScrolledWindowWindowPlacementPropertyInfo = "window-placement"
    type AttrOrigin ScrolledWindowWindowPlacementPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowWindowPlacement
    attrSet _ = setScrolledWindowWindowPlacement
    attrConstruct _ = constructScrolledWindowWindowPlacement
    attrClear _ = undefined
#endif

-- VVV Prop "window-placement-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getScrolledWindowWindowPlacementSet :: (MonadIO m, IsScrolledWindow o) => o -> m Bool
getScrolledWindowWindowPlacementSet obj = liftIO $ getObjectPropertyBool obj "window-placement-set"

setScrolledWindowWindowPlacementSet :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()
setScrolledWindowWindowPlacementSet obj val = liftIO $ setObjectPropertyBool obj "window-placement-set" val

constructScrolledWindowWindowPlacementSet :: (IsScrolledWindow o) => Bool -> IO (GValueConstruct o)
constructScrolledWindowWindowPlacementSet val = constructObjectPropertyBool "window-placement-set" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowWindowPlacementSetPropertyInfo
instance AttrInfo ScrolledWindowWindowPlacementSetPropertyInfo where
    type AttrAllowedOps ScrolledWindowWindowPlacementSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ScrolledWindowWindowPlacementSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ScrolledWindowWindowPlacementSetPropertyInfo = IsScrolledWindow
    type AttrGetType ScrolledWindowWindowPlacementSetPropertyInfo = Bool
    type AttrLabel ScrolledWindowWindowPlacementSetPropertyInfo = "window-placement-set"
    type AttrOrigin ScrolledWindowWindowPlacementSetPropertyInfo = ScrolledWindow
    attrGet _ = getScrolledWindowWindowPlacementSet
    attrSet _ = setScrolledWindowWindowPlacementSet
    attrConstruct _ = constructScrolledWindowWindowPlacementSet
    attrClear _ = undefined
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList ScrolledWindow
type instance O.AttributeList ScrolledWindow = ScrolledWindowAttributeList
type ScrolledWindowAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("hadjustment", ScrolledWindowHadjustmentPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hscrollbarPolicy", ScrolledWindowHscrollbarPolicyPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("kineticScrolling", ScrolledWindowKineticScrollingPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("maxContentHeight", ScrolledWindowMaxContentHeightPropertyInfo), '("maxContentWidth", ScrolledWindowMaxContentWidthPropertyInfo), '("minContentHeight", ScrolledWindowMinContentHeightPropertyInfo), '("minContentWidth", ScrolledWindowMinContentWidthPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overlayScrolling", ScrolledWindowOverlayScrollingPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("propagateNaturalHeight", ScrolledWindowPropagateNaturalHeightPropertyInfo), '("propagateNaturalWidth", ScrolledWindowPropagateNaturalWidthPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("shadowType", ScrolledWindowShadowTypePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("vadjustment", ScrolledWindowVadjustmentPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("vscrollbarPolicy", ScrolledWindowVscrollbarPolicyPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("windowPlacement", ScrolledWindowWindowPlacementPropertyInfo), '("windowPlacementSet", ScrolledWindowWindowPlacementSetPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
scrolledWindowHadjustment :: AttrLabelProxy "hadjustment"
scrolledWindowHadjustment = AttrLabelProxy

scrolledWindowHscrollbarPolicy :: AttrLabelProxy "hscrollbarPolicy"
scrolledWindowHscrollbarPolicy = AttrLabelProxy

scrolledWindowKineticScrolling :: AttrLabelProxy "kineticScrolling"
scrolledWindowKineticScrolling = AttrLabelProxy

scrolledWindowMaxContentHeight :: AttrLabelProxy "maxContentHeight"
scrolledWindowMaxContentHeight = AttrLabelProxy

scrolledWindowMaxContentWidth :: AttrLabelProxy "maxContentWidth"
scrolledWindowMaxContentWidth = AttrLabelProxy

scrolledWindowMinContentHeight :: AttrLabelProxy "minContentHeight"
scrolledWindowMinContentHeight = AttrLabelProxy

scrolledWindowMinContentWidth :: AttrLabelProxy "minContentWidth"
scrolledWindowMinContentWidth = AttrLabelProxy

scrolledWindowOverlayScrolling :: AttrLabelProxy "overlayScrolling"
scrolledWindowOverlayScrolling = AttrLabelProxy

scrolledWindowPropagateNaturalHeight :: AttrLabelProxy "propagateNaturalHeight"
scrolledWindowPropagateNaturalHeight = AttrLabelProxy

scrolledWindowPropagateNaturalWidth :: AttrLabelProxy "propagateNaturalWidth"
scrolledWindowPropagateNaturalWidth = AttrLabelProxy

scrolledWindowShadowType :: AttrLabelProxy "shadowType"
scrolledWindowShadowType = AttrLabelProxy

scrolledWindowVadjustment :: AttrLabelProxy "vadjustment"
scrolledWindowVadjustment = AttrLabelProxy

scrolledWindowVscrollbarPolicy :: AttrLabelProxy "vscrollbarPolicy"
scrolledWindowVscrollbarPolicy = AttrLabelProxy

scrolledWindowWindowPlacement :: AttrLabelProxy "windowPlacement"
scrolledWindowWindowPlacement = AttrLabelProxy

scrolledWindowWindowPlacementSet :: AttrLabelProxy "windowPlacementSet"
scrolledWindowWindowPlacementSet = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowEdgeOvershotSignalInfo
instance SignalInfo ScrolledWindowEdgeOvershotSignalInfo where
    type HaskellCallbackType ScrolledWindowEdgeOvershotSignalInfo = ScrolledWindowEdgeOvershotCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ScrolledWindowEdgeOvershotCallback cb
        cb'' <- mk_ScrolledWindowEdgeOvershotCallback cb'
        connectSignalFunPtr obj "edge-overshot" cb'' connectMode

data ScrolledWindowEdgeReachedSignalInfo
instance SignalInfo ScrolledWindowEdgeReachedSignalInfo where
    type HaskellCallbackType ScrolledWindowEdgeReachedSignalInfo = ScrolledWindowEdgeReachedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ScrolledWindowEdgeReachedCallback cb
        cb'' <- mk_ScrolledWindowEdgeReachedCallback cb'
        connectSignalFunPtr obj "edge-reached" cb'' connectMode

data ScrolledWindowMoveFocusOutSignalInfo
instance SignalInfo ScrolledWindowMoveFocusOutSignalInfo where
    type HaskellCallbackType ScrolledWindowMoveFocusOutSignalInfo = ScrolledWindowMoveFocusOutCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ScrolledWindowMoveFocusOutCallback cb
        cb'' <- mk_ScrolledWindowMoveFocusOutCallback cb'
        connectSignalFunPtr obj "move-focus-out" cb'' connectMode

data ScrolledWindowScrollChildSignalInfo
instance SignalInfo ScrolledWindowScrollChildSignalInfo where
    type HaskellCallbackType ScrolledWindowScrollChildSignalInfo = ScrolledWindowScrollChildCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ScrolledWindowScrollChildCallback cb
        cb'' <- mk_ScrolledWindowScrollChildCallback cb'
        connectSignalFunPtr obj "scroll-child" cb'' connectMode

type instance O.SignalList ScrolledWindow = ScrolledWindowSignalList
type ScrolledWindowSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("edgeOvershot", ScrolledWindowEdgeOvershotSignalInfo), '("edgeReached", ScrolledWindowEdgeReachedSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveFocusOut", ScrolledWindowMoveFocusOutSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollChild", ScrolledWindowScrollChildSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])

#endif

-- method ScrolledWindow::new
-- method type : Constructor
-- Args : [Arg {argCName = "hadjustment", argType = TInterface (Name {namespace = "Gtk", name = "Adjustment"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "horizontal adjustment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vadjustment", argType = TInterface (Name {namespace = "Gtk", name = "Adjustment"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "vertical adjustment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_new" gtk_scrolled_window_new :: 
    Ptr Gtk.Adjustment.Adjustment ->        -- hadjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
    Ptr Gtk.Adjustment.Adjustment ->        -- vadjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
    IO (Ptr ScrolledWindow)

{- |
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 'Nothing' for the adjustments, which
will cause the scrolled window to create them for you.
-}
scrolledWindowNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Adjustment.IsAdjustment a, Gtk.Adjustment.IsAdjustment b) =>
    Maybe (a)
    {- ^ /@hadjustment@/: horizontal adjustment -}
    -> Maybe (b)
    {- ^ /@vadjustment@/: vertical adjustment -}
    -> m ScrolledWindow
    {- ^ __Returns:__ a new scrolled window -}
scrolledWindowNew hadjustment vadjustment = liftIO $ do
    maybeHadjustment <- case hadjustment of
        Nothing -> return nullPtr
        Just jHadjustment -> do
            jHadjustment' <- unsafeManagedPtrCastPtr jHadjustment
            return jHadjustment'
    maybeVadjustment <- case vadjustment of
        Nothing -> return nullPtr
        Just jVadjustment -> do
            jVadjustment' <- unsafeManagedPtrCastPtr jVadjustment
            return jVadjustment'
    result <- gtk_scrolled_window_new maybeHadjustment maybeVadjustment
    checkUnexpectedReturnNULL "scrolledWindowNew" result
    result' <- (newObject ScrolledWindow) result
    whenJust hadjustment touchManagedPtr
    whenJust vadjustment touchManagedPtr
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

-- method ScrolledWindow::add_with_viewport
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget you want to scroll", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_add_with_viewport" gtk_scrolled_window_add_with_viewport :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{-# DEPRECATED scrolledWindowAddWithViewport ["(Since version 3.8)","'GI.Gtk.Objects.Container.containerAdd' will automatically add","a 'GI.Gtk.Objects.Viewport.Viewport' if the child doesn\8217t implement 'GI.Gtk.Interfaces.Scrollable.Scrollable'."] #-}
{- |
Used to add children without native scrolling capabilities. This
is simply a convenience function; it is equivalent to adding the
unscrollable child to a viewport, then adding the viewport to the
scrolled window. If a child has native scrolling, use
'GI.Gtk.Objects.Container.containerAdd' instead of this function.

The viewport scrolls the child by moving its 'GI.Gdk.Objects.Window.Window', and takes
the size of the child to be the size of its toplevel 'GI.Gdk.Objects.Window.Window'.
This will be very wrong for most widgets that support native scrolling;
for example, if you add a widget such as 'GI.Gtk.Objects.TreeView.TreeView' with a viewport,
the whole widget will scroll, including the column headings. Thus,
widgets with native scrolling support should not be used with the
'GI.Gtk.Objects.Viewport.Viewport' proxy.

A widget supports scrolling natively if it implements the
'GI.Gtk.Interfaces.Scrollable.Scrollable' interface.
-}
scrolledWindowAddWithViewport ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a, Gtk.Widget.IsWidget b) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> b
    {- ^ /@child@/: the widget you want to scroll -}
    -> m ()
scrolledWindowAddWithViewport scrolledWindow child = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    child' <- unsafeManagedPtrCastPtr child
    gtk_scrolled_window_add_with_viewport scrolledWindow' child'
    touchManagedPtr scrolledWindow
    touchManagedPtr child
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowAddWithViewportMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsScrolledWindow a, Gtk.Widget.IsWidget b) => O.MethodInfo ScrolledWindowAddWithViewportMethodInfo a signature where
    overloadedMethod _ = scrolledWindowAddWithViewport

#endif

-- method ScrolledWindow::get_capture_button_press
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_capture_button_press" gtk_scrolled_window_get_capture_button_press :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO CInt

{- |
Return whether button presses are captured during kinetic
scrolling. See 'GI.Gtk.Objects.ScrolledWindow.scrolledWindowSetCaptureButtonPress'.

@since 3.4
-}
scrolledWindowGetCaptureButtonPress ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if button presses are captured during kinetic scrolling -}
scrolledWindowGetCaptureButtonPress scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_capture_button_press scrolledWindow'
    let result' = (/= 0) result
    touchManagedPtr scrolledWindow
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetCaptureButtonPressMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetCaptureButtonPressMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetCaptureButtonPress

#endif

-- method ScrolledWindow::get_hadjustment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Adjustment"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_hadjustment" gtk_scrolled_window_get_hadjustment :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO (Ptr Gtk.Adjustment.Adjustment)

{- |
Returns the horizontal scrollbar’s adjustment, used to connect the
horizontal scrollbar to the child widget’s horizontal scroll
functionality.
-}
scrolledWindowGetHadjustment ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Gtk.Adjustment.Adjustment
    {- ^ __Returns:__ the horizontal 'GI.Gtk.Objects.Adjustment.Adjustment' -}
scrolledWindowGetHadjustment scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_hadjustment scrolledWindow'
    checkUnexpectedReturnNULL "scrolledWindowGetHadjustment" result
    result' <- (newObject Gtk.Adjustment.Adjustment) result
    touchManagedPtr scrolledWindow
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetHadjustmentMethodInfo
instance (signature ~ (m Gtk.Adjustment.Adjustment), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetHadjustmentMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetHadjustment

#endif

-- method ScrolledWindow::get_hscrollbar
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_hscrollbar" gtk_scrolled_window_get_hscrollbar :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO (Ptr Gtk.Widget.Widget)

{- |
Returns the horizontal scrollbar of /@scrolledWindow@/.

@since 2.8
-}
scrolledWindowGetHscrollbar ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Gtk.Widget.Widget
    {- ^ __Returns:__ the horizontal scrollbar of the scrolled window. -}
scrolledWindowGetHscrollbar scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_hscrollbar scrolledWindow'
    checkUnexpectedReturnNULL "scrolledWindowGetHscrollbar" result
    result' <- (newObject Gtk.Widget.Widget) result
    touchManagedPtr scrolledWindow
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetHscrollbarMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetHscrollbarMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetHscrollbar

#endif

-- method ScrolledWindow::get_kinetic_scrolling
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_kinetic_scrolling" gtk_scrolled_window_get_kinetic_scrolling :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO CInt

{- |
Returns the specified kinetic scrolling behavior.

@since 3.4
-}
scrolledWindowGetKineticScrolling ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Bool
    {- ^ __Returns:__ the scrolling behavior flags. -}
scrolledWindowGetKineticScrolling scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_kinetic_scrolling scrolledWindow'
    let result' = (/= 0) result
    touchManagedPtr scrolledWindow
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetKineticScrollingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetKineticScrollingMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetKineticScrolling

#endif

-- method ScrolledWindow::get_max_content_height
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_max_content_height" gtk_scrolled_window_get_max_content_height :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO Int32

{- |
Returns the maximum content height set.

@since 3.22
-}
scrolledWindowGetMaxContentHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Int32
    {- ^ __Returns:__ the maximum content height, or -1 -}
scrolledWindowGetMaxContentHeight scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_max_content_height scrolledWindow'
    touchManagedPtr scrolledWindow
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetMaxContentHeightMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetMaxContentHeightMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetMaxContentHeight

#endif

-- method ScrolledWindow::get_max_content_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_max_content_width" gtk_scrolled_window_get_max_content_width :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO Int32

{- |
Returns the maximum content width set.

@since 3.22
-}
scrolledWindowGetMaxContentWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Int32
    {- ^ __Returns:__ the maximum content width, or -1 -}
scrolledWindowGetMaxContentWidth scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_max_content_width scrolledWindow'
    touchManagedPtr scrolledWindow
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetMaxContentWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetMaxContentWidthMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetMaxContentWidth

#endif

-- method ScrolledWindow::get_min_content_height
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_min_content_height" gtk_scrolled_window_get_min_content_height :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO Int32

{- |
Gets the minimal content height of /@scrolledWindow@/, or -1 if not set.

@since 3.0
-}
scrolledWindowGetMinContentHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Int32
    {- ^ __Returns:__ the minimal content height -}
scrolledWindowGetMinContentHeight scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_min_content_height scrolledWindow'
    touchManagedPtr scrolledWindow
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetMinContentHeightMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetMinContentHeightMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetMinContentHeight

#endif

-- method ScrolledWindow::get_min_content_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_min_content_width" gtk_scrolled_window_get_min_content_width :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO Int32

{- |
Gets the minimum content width of /@scrolledWindow@/, or -1 if not set.

@since 3.0
-}
scrolledWindowGetMinContentWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Int32
    {- ^ __Returns:__ the minimum content width -}
scrolledWindowGetMinContentWidth scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_min_content_width scrolledWindow'
    touchManagedPtr scrolledWindow
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetMinContentWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetMinContentWidthMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetMinContentWidth

#endif

-- method ScrolledWindow::get_overlay_scrolling
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_overlay_scrolling" gtk_scrolled_window_get_overlay_scrolling :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO CInt

{- |
Returns whether overlay scrolling is enabled for this scrolled window.

@since 3.16
-}
scrolledWindowGetOverlayScrolling ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if overlay scrolling is enabled -}
scrolledWindowGetOverlayScrolling scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_overlay_scrolling scrolledWindow'
    let result' = (/= 0) result
    touchManagedPtr scrolledWindow
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetOverlayScrollingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetOverlayScrollingMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetOverlayScrolling

#endif

-- method ScrolledWindow::get_placement
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "CornerType"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_placement" gtk_scrolled_window_get_placement :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO CUInt

{- |
Gets the placement of the contents with respect to the scrollbars
for the scrolled window. See 'GI.Gtk.Objects.ScrolledWindow.scrolledWindowSetPlacement'.
-}
scrolledWindowGetPlacement ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Gtk.Enums.CornerType
    {- ^ __Returns:__ the current placement value.

See also 'GI.Gtk.Objects.ScrolledWindow.scrolledWindowSetPlacement' and
'GI.Gtk.Objects.ScrolledWindow.scrolledWindowUnsetPlacement'. -}
scrolledWindowGetPlacement scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_placement scrolledWindow'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr scrolledWindow
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetPlacementMethodInfo
instance (signature ~ (m Gtk.Enums.CornerType), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetPlacementMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetPlacement

#endif

-- method ScrolledWindow::get_policy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hscrollbar_policy", argType = TInterface (Name {namespace = "Gtk", name = "PolicyType"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the policy\n    for the horizontal scrollbar, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "vscrollbar_policy", argType = TInterface (Name {namespace = "Gtk", name = "PolicyType"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the policy\n    for the vertical scrollbar, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_policy" gtk_scrolled_window_get_policy :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    Ptr CUInt ->                            -- hscrollbar_policy : TInterface (Name {namespace = "Gtk", name = "PolicyType"})
    Ptr CUInt ->                            -- vscrollbar_policy : TInterface (Name {namespace = "Gtk", name = "PolicyType"})
    IO ()

{- |
Retrieves the current policy values for the horizontal and vertical
scrollbars. See 'GI.Gtk.Objects.ScrolledWindow.scrolledWindowSetPolicy'.
-}
scrolledWindowGetPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m ((Gtk.Enums.PolicyType, Gtk.Enums.PolicyType))
scrolledWindowGetPolicy scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    hscrollbarPolicy <- allocMem :: IO (Ptr CUInt)
    vscrollbarPolicy <- allocMem :: IO (Ptr CUInt)
    gtk_scrolled_window_get_policy scrolledWindow' hscrollbarPolicy vscrollbarPolicy
    hscrollbarPolicy' <- peek hscrollbarPolicy
    let hscrollbarPolicy'' = (toEnum . fromIntegral) hscrollbarPolicy'
    vscrollbarPolicy' <- peek vscrollbarPolicy
    let vscrollbarPolicy'' = (toEnum . fromIntegral) vscrollbarPolicy'
    touchManagedPtr scrolledWindow
    freeMem hscrollbarPolicy
    freeMem vscrollbarPolicy
    return (hscrollbarPolicy'', vscrollbarPolicy'')

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetPolicyMethodInfo
instance (signature ~ (m ((Gtk.Enums.PolicyType, Gtk.Enums.PolicyType))), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetPolicyMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetPolicy

#endif

-- method ScrolledWindow::get_propagate_natural_height
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_propagate_natural_height" gtk_scrolled_window_get_propagate_natural_height :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO CInt

{- |
Reports whether the natural height of the child will be calculated and propagated
through the scrolled windows requested natural height.

@since 3.22
-}
scrolledWindowGetPropagateNaturalHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Bool
    {- ^ __Returns:__ whether natural height propagation is enabled. -}
scrolledWindowGetPropagateNaturalHeight scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_propagate_natural_height scrolledWindow'
    let result' = (/= 0) result
    touchManagedPtr scrolledWindow
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetPropagateNaturalHeightMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetPropagateNaturalHeightMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetPropagateNaturalHeight

#endif

-- method ScrolledWindow::get_propagate_natural_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_propagate_natural_width" gtk_scrolled_window_get_propagate_natural_width :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO CInt

{- |
Reports whether the natural width of the child will be calculated and propagated
through the scrolled windows requested natural width.

@since 3.22
-}
scrolledWindowGetPropagateNaturalWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Bool
    {- ^ __Returns:__ whether natural width propagation is enabled. -}
scrolledWindowGetPropagateNaturalWidth scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_propagate_natural_width scrolledWindow'
    let result' = (/= 0) result
    touchManagedPtr scrolledWindow
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetPropagateNaturalWidthMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetPropagateNaturalWidthMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetPropagateNaturalWidth

#endif

-- method ScrolledWindow::get_shadow_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "ShadowType"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_shadow_type" gtk_scrolled_window_get_shadow_type :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO CUInt

{- |
Gets the shadow type of the scrolled window. See
'GI.Gtk.Objects.ScrolledWindow.scrolledWindowSetShadowType'.
-}
scrolledWindowGetShadowType ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Gtk.Enums.ShadowType
    {- ^ __Returns:__ the current shadow type -}
scrolledWindowGetShadowType scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_shadow_type scrolledWindow'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr scrolledWindow
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetShadowTypeMethodInfo
instance (signature ~ (m Gtk.Enums.ShadowType), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetShadowTypeMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetShadowType

#endif

-- method ScrolledWindow::get_vadjustment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Adjustment"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_vadjustment" gtk_scrolled_window_get_vadjustment :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO (Ptr Gtk.Adjustment.Adjustment)

{- |
Returns the vertical scrollbar’s adjustment, used to connect the
vertical scrollbar to the child widget’s vertical scroll functionality.
-}
scrolledWindowGetVadjustment ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Gtk.Adjustment.Adjustment
    {- ^ __Returns:__ the vertical 'GI.Gtk.Objects.Adjustment.Adjustment' -}
scrolledWindowGetVadjustment scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_vadjustment scrolledWindow'
    checkUnexpectedReturnNULL "scrolledWindowGetVadjustment" result
    result' <- (newObject Gtk.Adjustment.Adjustment) result
    touchManagedPtr scrolledWindow
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetVadjustmentMethodInfo
instance (signature ~ (m Gtk.Adjustment.Adjustment), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetVadjustmentMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetVadjustment

#endif

-- method ScrolledWindow::get_vscrollbar
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_get_vscrollbar" gtk_scrolled_window_get_vscrollbar :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO (Ptr Gtk.Widget.Widget)

{- |
Returns the vertical scrollbar of /@scrolledWindow@/.

@since 2.8
-}
scrolledWindowGetVscrollbar ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m Gtk.Widget.Widget
    {- ^ __Returns:__ the vertical scrollbar of the scrolled window. -}
scrolledWindowGetVscrollbar scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    result <- gtk_scrolled_window_get_vscrollbar scrolledWindow'
    checkUnexpectedReturnNULL "scrolledWindowGetVscrollbar" result
    result' <- (newObject Gtk.Widget.Widget) result
    touchManagedPtr scrolledWindow
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowGetVscrollbarMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowGetVscrollbarMethodInfo a signature where
    overloadedMethod _ = scrolledWindowGetVscrollbar

#endif

-- method ScrolledWindow::set_capture_button_press
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "capture_button_press", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to capture button presses", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_capture_button_press" gtk_scrolled_window_set_capture_button_press :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    CInt ->                                 -- capture_button_press : TBasicType TBoolean
    IO ()

{- |
Changes the behaviour of /@scrolledWindow@/ with regard to the initial
event that possibly starts kinetic scrolling. When /@captureButtonPress@/
is set to 'True', the event is captured by the scrolled window, and
then later replayed if it is meant to go to the child widget.

This should be enabled if any child widgets perform non-reversible
actions on 'GI.Gtk.Objects.Widget.Widget'::@/button-press-event/@. If they don\'t, and handle
additionally handle 'GI.Gtk.Objects.Widget.Widget'::@/grab-broken-event/@, it might be better
to set /@captureButtonPress@/ to 'False'.

This setting only has an effect if kinetic scrolling is enabled.

@since 3.4
-}
scrolledWindowSetCaptureButtonPress ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> Bool
    {- ^ /@captureButtonPress@/: 'True' to capture button presses -}
    -> m ()
scrolledWindowSetCaptureButtonPress scrolledWindow captureButtonPress = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    let captureButtonPress' = (fromIntegral . fromEnum) captureButtonPress
    gtk_scrolled_window_set_capture_button_press scrolledWindow' captureButtonPress'
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetCaptureButtonPressMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowSetCaptureButtonPressMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetCaptureButtonPress

#endif

-- method ScrolledWindow::set_hadjustment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hadjustment", argType = TInterface (Name {namespace = "Gtk", name = "Adjustment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "horizontal scroll adjustment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_hadjustment" gtk_scrolled_window_set_hadjustment :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    Ptr Gtk.Adjustment.Adjustment ->        -- hadjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
    IO ()

{- |
Sets the 'GI.Gtk.Objects.Adjustment.Adjustment' for the horizontal scrollbar.
-}
scrolledWindowSetHadjustment ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a, Gtk.Adjustment.IsAdjustment b) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> b
    {- ^ /@hadjustment@/: horizontal scroll adjustment -}
    -> m ()
scrolledWindowSetHadjustment scrolledWindow hadjustment = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    hadjustment' <- unsafeManagedPtrCastPtr hadjustment
    gtk_scrolled_window_set_hadjustment scrolledWindow' hadjustment'
    touchManagedPtr scrolledWindow
    touchManagedPtr hadjustment
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetHadjustmentMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsScrolledWindow a, Gtk.Adjustment.IsAdjustment b) => O.MethodInfo ScrolledWindowSetHadjustmentMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetHadjustment

#endif

-- method ScrolledWindow::set_kinetic_scrolling
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "kinetic_scrolling", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to enable kinetic scrolling", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_kinetic_scrolling" gtk_scrolled_window_set_kinetic_scrolling :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    CInt ->                                 -- kinetic_scrolling : TBasicType TBoolean
    IO ()

{- |
Turns kinetic scrolling on or off.
Kinetic scrolling only applies to devices with source
'GI.Gdk.Enums.InputSourceTouchscreen'.

@since 3.4
-}
scrolledWindowSetKineticScrolling ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> Bool
    {- ^ /@kineticScrolling@/: 'True' to enable kinetic scrolling -}
    -> m ()
scrolledWindowSetKineticScrolling scrolledWindow kineticScrolling = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    let kineticScrolling' = (fromIntegral . fromEnum) kineticScrolling
    gtk_scrolled_window_set_kinetic_scrolling scrolledWindow' kineticScrolling'
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetKineticScrollingMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowSetKineticScrollingMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetKineticScrolling

#endif

-- method ScrolledWindow::set_max_content_height
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum content height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_max_content_height" gtk_scrolled_window_set_max_content_height :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    Int32 ->                                -- height : TBasicType TInt
    IO ()

{- |
Sets the maximum height that /@scrolledWindow@/ should keep visible. The
/@scrolledWindow@/ will grow up to this height before it starts scrolling
the content.

It is a programming error to set the maximum content height to a value
smaller than 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow':@/min-content-height/@.

@since 3.22
-}
scrolledWindowSetMaxContentHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> Int32
    {- ^ /@height@/: the maximum content height -}
    -> m ()
scrolledWindowSetMaxContentHeight scrolledWindow height = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    gtk_scrolled_window_set_max_content_height scrolledWindow' height
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetMaxContentHeightMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowSetMaxContentHeightMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetMaxContentHeight

#endif

-- method ScrolledWindow::set_max_content_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum content width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_max_content_width" gtk_scrolled_window_set_max_content_width :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    Int32 ->                                -- width : TBasicType TInt
    IO ()

{- |
Sets the maximum width that /@scrolledWindow@/ should keep visible. The
/@scrolledWindow@/ will grow up to this width before it starts scrolling
the content.

It is a programming error to set the maximum content width to a value
smaller than 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow':@/min-content-width/@.

@since 3.22
-}
scrolledWindowSetMaxContentWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> Int32
    {- ^ /@width@/: the maximum content width -}
    -> m ()
scrolledWindowSetMaxContentWidth scrolledWindow width = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    gtk_scrolled_window_set_max_content_width scrolledWindow' width
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetMaxContentWidthMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowSetMaxContentWidthMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetMaxContentWidth

#endif

-- method ScrolledWindow::set_min_content_height
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimal content height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_min_content_height" gtk_scrolled_window_set_min_content_height :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    Int32 ->                                -- height : TBasicType TInt
    IO ()

{- |
Sets the minimum height that /@scrolledWindow@/ should keep visible.
Note that this can and (usually will) be smaller than the minimum
size of the content.

It is a programming error to set the minimum content height to a
value greater than 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow':@/max-content-height/@.

@since 3.0
-}
scrolledWindowSetMinContentHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> Int32
    {- ^ /@height@/: the minimal content height -}
    -> m ()
scrolledWindowSetMinContentHeight scrolledWindow height = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    gtk_scrolled_window_set_min_content_height scrolledWindow' height
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetMinContentHeightMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowSetMinContentHeightMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetMinContentHeight

#endif

-- method ScrolledWindow::set_min_content_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimal content width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_min_content_width" gtk_scrolled_window_set_min_content_width :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    Int32 ->                                -- width : TBasicType TInt
    IO ()

{- |
Sets the minimum width that /@scrolledWindow@/ should keep visible.
Note that this can and (usually will) be smaller than the minimum
size of the content.

It is a programming error to set the minimum content width to a
value greater than 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow':@/max-content-width/@.

@since 3.0
-}
scrolledWindowSetMinContentWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> Int32
    {- ^ /@width@/: the minimal content width -}
    -> m ()
scrolledWindowSetMinContentWidth scrolledWindow width = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    gtk_scrolled_window_set_min_content_width scrolledWindow' width
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetMinContentWidthMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowSetMinContentWidthMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetMinContentWidth

#endif

-- method ScrolledWindow::set_overlay_scrolling
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "overlay_scrolling", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to enable overlay scrolling", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_overlay_scrolling" gtk_scrolled_window_set_overlay_scrolling :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    CInt ->                                 -- overlay_scrolling : TBasicType TBoolean
    IO ()

{- |
Enables or disables overlay scrolling for this scrolled window.

@since 3.16
-}
scrolledWindowSetOverlayScrolling ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> Bool
    {- ^ /@overlayScrolling@/: whether to enable overlay scrolling -}
    -> m ()
scrolledWindowSetOverlayScrolling scrolledWindow overlayScrolling = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    let overlayScrolling' = (fromIntegral . fromEnum) overlayScrolling
    gtk_scrolled_window_set_overlay_scrolling scrolledWindow' overlayScrolling'
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetOverlayScrollingMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowSetOverlayScrollingMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetOverlayScrolling

#endif

-- method ScrolledWindow::set_placement
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window_placement", argType = TInterface (Name {namespace = "Gtk", name = "CornerType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position of the child window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_placement" gtk_scrolled_window_set_placement :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    CUInt ->                                -- window_placement : TInterface (Name {namespace = "Gtk", name = "CornerType"})
    IO ()

{- |
Sets the placement of the contents with respect to the scrollbars
for the scrolled window.

The default is 'GI.Gtk.Enums.CornerTypeTopLeft', meaning the child is
in the top left, with the scrollbars underneath and to the right.
Other values in 'GI.Gtk.Enums.CornerType' are 'GI.Gtk.Enums.CornerTypeTopRight',
'GI.Gtk.Enums.CornerTypeBottomLeft', and 'GI.Gtk.Enums.CornerTypeBottomRight'.

See also 'GI.Gtk.Objects.ScrolledWindow.scrolledWindowGetPlacement' and
'GI.Gtk.Objects.ScrolledWindow.scrolledWindowUnsetPlacement'.
-}
scrolledWindowSetPlacement ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> Gtk.Enums.CornerType
    {- ^ /@windowPlacement@/: position of the child window -}
    -> m ()
scrolledWindowSetPlacement scrolledWindow windowPlacement = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    let windowPlacement' = (fromIntegral . fromEnum) windowPlacement
    gtk_scrolled_window_set_placement scrolledWindow' windowPlacement'
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetPlacementMethodInfo
instance (signature ~ (Gtk.Enums.CornerType -> m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowSetPlacementMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetPlacement

#endif

-- method ScrolledWindow::set_policy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hscrollbar_policy", argType = TInterface (Name {namespace = "Gtk", name = "PolicyType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "policy for horizontal bar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vscrollbar_policy", argType = TInterface (Name {namespace = "Gtk", name = "PolicyType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "policy for vertical bar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_policy" gtk_scrolled_window_set_policy :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    CUInt ->                                -- hscrollbar_policy : TInterface (Name {namespace = "Gtk", name = "PolicyType"})
    CUInt ->                                -- vscrollbar_policy : TInterface (Name {namespace = "Gtk", name = "PolicyType"})
    IO ()

{- |
Sets the scrollbar policy for the horizontal and vertical scrollbars.

The policy determines when the scrollbar should appear; it is a value
from the 'GI.Gtk.Enums.PolicyType' enumeration. If 'GI.Gtk.Enums.PolicyTypeAlways', the
scrollbar is always present; if 'GI.Gtk.Enums.PolicyTypeNever', the scrollbar is
never present; if 'GI.Gtk.Enums.PolicyTypeAutomatic', 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).
-}
scrolledWindowSetPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> Gtk.Enums.PolicyType
    {- ^ /@hscrollbarPolicy@/: policy for horizontal bar -}
    -> Gtk.Enums.PolicyType
    {- ^ /@vscrollbarPolicy@/: policy for vertical bar -}
    -> m ()
scrolledWindowSetPolicy scrolledWindow hscrollbarPolicy vscrollbarPolicy = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    let hscrollbarPolicy' = (fromIntegral . fromEnum) hscrollbarPolicy
    let vscrollbarPolicy' = (fromIntegral . fromEnum) vscrollbarPolicy
    gtk_scrolled_window_set_policy scrolledWindow' hscrollbarPolicy' vscrollbarPolicy'
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetPolicyMethodInfo
instance (signature ~ (Gtk.Enums.PolicyType -> Gtk.Enums.PolicyType -> m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowSetPolicyMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetPolicy

#endif

-- method ScrolledWindow::set_propagate_natural_height
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "propagate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to propagate natural height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_propagate_natural_height" gtk_scrolled_window_set_propagate_natural_height :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    CInt ->                                 -- propagate : TBasicType TBoolean
    IO ()

{- |
Sets whether the natural height of the child should be calculated and propagated
through the scrolled windows requested natural height.

@since 3.22
-}
scrolledWindowSetPropagateNaturalHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> Bool
    {- ^ /@propagate@/: whether to propagate natural height -}
    -> m ()
scrolledWindowSetPropagateNaturalHeight scrolledWindow propagate = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    let propagate' = (fromIntegral . fromEnum) propagate
    gtk_scrolled_window_set_propagate_natural_height scrolledWindow' propagate'
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetPropagateNaturalHeightMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowSetPropagateNaturalHeightMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetPropagateNaturalHeight

#endif

-- method ScrolledWindow::set_propagate_natural_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "propagate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to propagate natural width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_propagate_natural_width" gtk_scrolled_window_set_propagate_natural_width :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    CInt ->                                 -- propagate : TBasicType TBoolean
    IO ()

{- |
Sets whether the natural width of the child should be calculated and propagated
through the scrolled windows requested natural width.

@since 3.22
-}
scrolledWindowSetPropagateNaturalWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> Bool
    {- ^ /@propagate@/: whether to propagate natural width -}
    -> m ()
scrolledWindowSetPropagateNaturalWidth scrolledWindow propagate = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    let propagate' = (fromIntegral . fromEnum) propagate
    gtk_scrolled_window_set_propagate_natural_width scrolledWindow' propagate'
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetPropagateNaturalWidthMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowSetPropagateNaturalWidthMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetPropagateNaturalWidth

#endif

-- method ScrolledWindow::set_shadow_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Gtk", name = "ShadowType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "kind of shadow to draw around scrolled window contents", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_shadow_type" gtk_scrolled_window_set_shadow_type :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    CUInt ->                                -- type : TInterface (Name {namespace = "Gtk", name = "ShadowType"})
    IO ()

{- |
Changes the type of shadow drawn around the contents of
/@scrolledWindow@/.
-}
scrolledWindowSetShadowType ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> Gtk.Enums.ShadowType
    {- ^ /@type@/: kind of shadow to draw around scrolled window contents -}
    -> m ()
scrolledWindowSetShadowType scrolledWindow type_ = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    let type_' = (fromIntegral . fromEnum) type_
    gtk_scrolled_window_set_shadow_type scrolledWindow' type_'
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetShadowTypeMethodInfo
instance (signature ~ (Gtk.Enums.ShadowType -> m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowSetShadowTypeMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetShadowType

#endif

-- method ScrolledWindow::set_vadjustment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vadjustment", argType = TInterface (Name {namespace = "Gtk", name = "Adjustment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "vertical scroll adjustment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_set_vadjustment" gtk_scrolled_window_set_vadjustment :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    Ptr Gtk.Adjustment.Adjustment ->        -- vadjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
    IO ()

{- |
Sets the 'GI.Gtk.Objects.Adjustment.Adjustment' for the vertical scrollbar.
-}
scrolledWindowSetVadjustment ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a, Gtk.Adjustment.IsAdjustment b) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> b
    {- ^ /@vadjustment@/: vertical scroll adjustment -}
    -> m ()
scrolledWindowSetVadjustment scrolledWindow vadjustment = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    vadjustment' <- unsafeManagedPtrCastPtr vadjustment
    gtk_scrolled_window_set_vadjustment scrolledWindow' vadjustment'
    touchManagedPtr scrolledWindow
    touchManagedPtr vadjustment
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowSetVadjustmentMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsScrolledWindow a, Gtk.Adjustment.IsAdjustment b) => O.MethodInfo ScrolledWindowSetVadjustmentMethodInfo a signature where
    overloadedMethod _ = scrolledWindowSetVadjustment

#endif

-- method ScrolledWindow::unset_placement
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "scrolled_window", argType = TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkScrolledWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scrolled_window_unset_placement" gtk_scrolled_window_unset_placement :: 
    Ptr ScrolledWindow ->                   -- scrolled_window : TInterface (Name {namespace = "Gtk", name = "ScrolledWindow"})
    IO ()

{- |
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 defaults to 'GI.Gtk.Enums.CornerTypeTopLeft'.

See also 'GI.Gtk.Objects.ScrolledWindow.scrolledWindowSetPlacement' and
'GI.Gtk.Objects.ScrolledWindow.scrolledWindowGetPlacement'.

@since 2.10
-}
scrolledWindowUnsetPlacement ::
    (B.CallStack.HasCallStack, MonadIO m, IsScrolledWindow a) =>
    a
    {- ^ /@scrolledWindow@/: a 'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow' -}
    -> m ()
scrolledWindowUnsetPlacement scrolledWindow = liftIO $ do
    scrolledWindow' <- unsafeManagedPtrCastPtr scrolledWindow
    gtk_scrolled_window_unset_placement scrolledWindow'
    touchManagedPtr scrolledWindow
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ScrolledWindowUnsetPlacementMethodInfo
instance (signature ~ (m ()), MonadIO m, IsScrolledWindow a) => O.MethodInfo ScrolledWindowUnsetPlacementMethodInfo a signature where
    overloadedMethod _ = scrolledWindowUnsetPlacement

#endif