{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A scrollable [class/@clamp@/].
-- 
-- @AdwClampScrollable@ is a variant of [class/@clamp@/] that implements the
-- t'GI.Gtk.Interfaces.Scrollable.Scrollable' interface.
-- 
-- The primary use case for @AdwClampScrollable@ is clamping
-- t'GI.Gtk.Objects.ListView.ListView'.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Adw.Objects.ClampScrollable
    ( 

-- * Exported types
    ClampScrollable(..)                     ,
    IsClampScrollable                       ,
    toClampScrollable                       ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBorder]("GI.Gtk.Interfaces.Scrollable#g:method:getBorder"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChild]("GI.Adw.Objects.ClampScrollable#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:getHadjustment"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getHscrollPolicy"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getMaximumSize]("GI.Adw.Objects.ClampScrollable#g:method:getMaximumSize"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOrientation]("GI.Gtk.Interfaces.Orientable#g:method:getOrientation"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTighteningThreshold]("GI.Adw.Objects.ClampScrollable#g:method:getTighteningThreshold"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getVadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:getVadjustment"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getVscrollPolicy"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
-- 
-- ==== Setters
-- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChild]("GI.Adw.Objects.ClampScrollable#g:method:setChild"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:setHadjustment"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setHscrollPolicy"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMaximumSize]("GI.Adw.Objects.ClampScrollable#g:method:setMaximumSize"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOrientation]("GI.Gtk.Interfaces.Orientable#g:method:setOrientation"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTighteningThreshold]("GI.Adw.Objects.ClampScrollable#g:method:setTighteningThreshold"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setVadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:setVadjustment"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setVscrollPolicy").

#if defined(ENABLE_OVERLOADING)
    ResolveClampScrollableMethod            ,
#endif

-- ** getChild #method:getChild#

#if defined(ENABLE_OVERLOADING)
    ClampScrollableGetChildMethodInfo       ,
#endif
    clampScrollableGetChild                 ,


-- ** getMaximumSize #method:getMaximumSize#

#if defined(ENABLE_OVERLOADING)
    ClampScrollableGetMaximumSizeMethodInfo ,
#endif
    clampScrollableGetMaximumSize           ,


-- ** getTighteningThreshold #method:getTighteningThreshold#

#if defined(ENABLE_OVERLOADING)
    ClampScrollableGetTighteningThresholdMethodInfo,
#endif
    clampScrollableGetTighteningThreshold   ,


-- ** new #method:new#

    clampScrollableNew                      ,


-- ** setChild #method:setChild#

#if defined(ENABLE_OVERLOADING)
    ClampScrollableSetChildMethodInfo       ,
#endif
    clampScrollableSetChild                 ,


-- ** setMaximumSize #method:setMaximumSize#

#if defined(ENABLE_OVERLOADING)
    ClampScrollableSetMaximumSizeMethodInfo ,
#endif
    clampScrollableSetMaximumSize           ,


-- ** setTighteningThreshold #method:setTighteningThreshold#

#if defined(ENABLE_OVERLOADING)
    ClampScrollableSetTighteningThresholdMethodInfo,
#endif
    clampScrollableSetTighteningThreshold   ,




 -- * Properties


-- ** child #attr:child#
-- | The child widget of the @AdwClampScrollable@.

#if defined(ENABLE_OVERLOADING)
    ClampScrollableChildPropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    clampScrollableChild                    ,
#endif
    clearClampScrollableChild               ,
    constructClampScrollableChild           ,
    getClampScrollableChild                 ,
    setClampScrollableChild                 ,


-- ** maximumSize #attr:maximumSize#
-- | The maximum size allocated to the child.
-- 
-- It is the width if the clamp is horizontal, or the height if it is vertical.

#if defined(ENABLE_OVERLOADING)
    ClampScrollableMaximumSizePropertyInfo  ,
#endif
#if defined(ENABLE_OVERLOADING)
    clampScrollableMaximumSize              ,
#endif
    constructClampScrollableMaximumSize     ,
    getClampScrollableMaximumSize           ,
    setClampScrollableMaximumSize           ,


-- ** tighteningThreshold #attr:tighteningThreshold#
-- | The size above which the child is clamped.
-- 
-- Starting from this size, the clamp will tighten its grip on the child,
-- slowly allocating less and less of the available size up to the maximum
-- allocated size. Below that threshold and below the maximum width, the child
-- will be allocated all the available size.
-- 
-- If the threshold is greater than the maximum size to allocate to the child,
-- the child will be allocated all the width up to the maximum.
-- If the threshold is lower than the minimum size to allocate to the child,
-- that size will be used as the tightening threshold.
-- 
-- Effectively, tightening the grip on the child before it reaches its maximum
-- size makes transitions to and from the maximum size smoother when resizing.

#if defined(ENABLE_OVERLOADING)
    ClampScrollableTighteningThresholdPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    clampScrollableTighteningThreshold      ,
#endif
    constructClampScrollableTighteningThreshold,
    getClampScrollableTighteningThreshold   ,
    setClampScrollableTighteningThreshold   ,




    ) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import qualified GI.Gtk.Interfaces.Orientable as Gtk.Orientable
import qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

-- | Memory-managed wrapper type.
newtype ClampScrollable = ClampScrollable (SP.ManagedPtr ClampScrollable)
    deriving (ClampScrollable -> ClampScrollable -> Bool
(ClampScrollable -> ClampScrollable -> Bool)
-> (ClampScrollable -> ClampScrollable -> Bool)
-> Eq ClampScrollable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClampScrollable -> ClampScrollable -> Bool
== :: ClampScrollable -> ClampScrollable -> Bool
$c/= :: ClampScrollable -> ClampScrollable -> Bool
/= :: ClampScrollable -> ClampScrollable -> Bool
Eq)

instance SP.ManagedPtrNewtype ClampScrollable where
    toManagedPtr :: ClampScrollable -> ManagedPtr ClampScrollable
toManagedPtr (ClampScrollable ManagedPtr ClampScrollable
p) = ManagedPtr ClampScrollable
p

foreign import ccall "adw_clamp_scrollable_get_type"
    c_adw_clamp_scrollable_get_type :: IO B.Types.GType

instance B.Types.TypedObject ClampScrollable where
    glibType :: IO GType
glibType = IO GType
c_adw_clamp_scrollable_get_type

instance B.Types.GObject ClampScrollable

-- | Type class for types which can be safely cast to `ClampScrollable`, for instance with `toClampScrollable`.
class (SP.GObject o, O.IsDescendantOf ClampScrollable o) => IsClampScrollable o
instance (SP.GObject o, O.IsDescendantOf ClampScrollable o) => IsClampScrollable o

instance O.HasParentTypes ClampScrollable
type instance O.ParentTypes ClampScrollable = '[Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget, Gtk.Orientable.Orientable, Gtk.Scrollable.Scrollable]

-- | Cast to `ClampScrollable`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toClampScrollable :: (MIO.MonadIO m, IsClampScrollable o) => o -> m ClampScrollable
toClampScrollable :: forall (m :: * -> *) o.
(MonadIO m, IsClampScrollable o) =>
o -> m ClampScrollable
toClampScrollable = IO ClampScrollable -> m ClampScrollable
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ClampScrollable -> m ClampScrollable)
-> (o -> IO ClampScrollable) -> o -> m ClampScrollable
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ClampScrollable -> ClampScrollable)
-> o -> IO ClampScrollable
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ClampScrollable -> ClampScrollable
ClampScrollable

-- | Convert 'ClampScrollable' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe ClampScrollable) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_adw_clamp_scrollable_get_type
    gvalueSet_ :: Ptr GValue -> Maybe ClampScrollable -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ClampScrollable
P.Nothing = Ptr GValue -> Ptr ClampScrollable -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ClampScrollable
forall a. Ptr a
FP.nullPtr :: FP.Ptr ClampScrollable)
    gvalueSet_ Ptr GValue
gv (P.Just ClampScrollable
obj) = ClampScrollable -> (Ptr ClampScrollable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ClampScrollable
obj (Ptr GValue -> Ptr ClampScrollable -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe ClampScrollable)
gvalueGet_ Ptr GValue
gv = do
        Ptr ClampScrollable
ptr <- Ptr GValue -> IO (Ptr ClampScrollable)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ClampScrollable)
        if Ptr ClampScrollable
ptr Ptr ClampScrollable -> Ptr ClampScrollable -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ClampScrollable
forall a. Ptr a
FP.nullPtr
        then ClampScrollable -> Maybe ClampScrollable
forall a. a -> Maybe a
P.Just (ClampScrollable -> Maybe ClampScrollable)
-> IO ClampScrollable -> IO (Maybe ClampScrollable)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ClampScrollable -> ClampScrollable)
-> Ptr ClampScrollable -> IO ClampScrollable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ClampScrollable -> ClampScrollable
ClampScrollable Ptr ClampScrollable
ptr
        else Maybe ClampScrollable -> IO (Maybe ClampScrollable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ClampScrollable
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveClampScrollableMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveClampScrollableMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveClampScrollableMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveClampScrollableMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveClampScrollableMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveClampScrollableMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveClampScrollableMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveClampScrollableMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveClampScrollableMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveClampScrollableMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveClampScrollableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveClampScrollableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveClampScrollableMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveClampScrollableMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveClampScrollableMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveClampScrollableMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveClampScrollableMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveClampScrollableMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveClampScrollableMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveClampScrollableMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveClampScrollableMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveClampScrollableMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveClampScrollableMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveClampScrollableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveClampScrollableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveClampScrollableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveClampScrollableMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveClampScrollableMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveClampScrollableMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveClampScrollableMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveClampScrollableMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveClampScrollableMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveClampScrollableMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveClampScrollableMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveClampScrollableMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveClampScrollableMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveClampScrollableMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveClampScrollableMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveClampScrollableMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveClampScrollableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveClampScrollableMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveClampScrollableMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveClampScrollableMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveClampScrollableMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveClampScrollableMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveClampScrollableMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveClampScrollableMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveClampScrollableMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveClampScrollableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveClampScrollableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveClampScrollableMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveClampScrollableMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveClampScrollableMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveClampScrollableMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveClampScrollableMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveClampScrollableMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveClampScrollableMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveClampScrollableMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveClampScrollableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveClampScrollableMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveClampScrollableMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveClampScrollableMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveClampScrollableMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveClampScrollableMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveClampScrollableMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveClampScrollableMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveClampScrollableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveClampScrollableMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveClampScrollableMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveClampScrollableMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveClampScrollableMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveClampScrollableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveClampScrollableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveClampScrollableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveClampScrollableMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveClampScrollableMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveClampScrollableMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveClampScrollableMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveClampScrollableMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveClampScrollableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveClampScrollableMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveClampScrollableMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
    ResolveClampScrollableMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveClampScrollableMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveClampScrollableMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveClampScrollableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveClampScrollableMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
    ResolveClampScrollableMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveClampScrollableMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveClampScrollableMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveClampScrollableMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveClampScrollableMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveClampScrollableMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveClampScrollableMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
    ResolveClampScrollableMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo
    ResolveClampScrollableMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
    ResolveClampScrollableMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveClampScrollableMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveClampScrollableMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveClampScrollableMethod "getChild" o = ClampScrollableGetChildMethodInfo
    ResolveClampScrollableMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveClampScrollableMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveClampScrollableMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
    ResolveClampScrollableMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveClampScrollableMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveClampScrollableMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveClampScrollableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveClampScrollableMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveClampScrollableMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveClampScrollableMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
    ResolveClampScrollableMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveClampScrollableMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveClampScrollableMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveClampScrollableMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveClampScrollableMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveClampScrollableMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveClampScrollableMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveClampScrollableMethod "getHadjustment" o = Gtk.Scrollable.ScrollableGetHadjustmentMethodInfo
    ResolveClampScrollableMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveClampScrollableMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveClampScrollableMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveClampScrollableMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveClampScrollableMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveClampScrollableMethod "getHscrollPolicy" o = Gtk.Scrollable.ScrollableGetHscrollPolicyMethodInfo
    ResolveClampScrollableMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveClampScrollableMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveClampScrollableMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveClampScrollableMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveClampScrollableMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveClampScrollableMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveClampScrollableMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveClampScrollableMethod "getMaximumSize" o = ClampScrollableGetMaximumSizeMethodInfo
    ResolveClampScrollableMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveClampScrollableMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveClampScrollableMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
    ResolveClampScrollableMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveClampScrollableMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveClampScrollableMethod "getOrientation" o = Gtk.Orientable.OrientableGetOrientationMethodInfo
    ResolveClampScrollableMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveClampScrollableMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveClampScrollableMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveClampScrollableMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
    ResolveClampScrollableMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveClampScrollableMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveClampScrollableMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveClampScrollableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveClampScrollableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveClampScrollableMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveClampScrollableMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveClampScrollableMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveClampScrollableMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveClampScrollableMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveClampScrollableMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveClampScrollableMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveClampScrollableMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveClampScrollableMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveClampScrollableMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveClampScrollableMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveClampScrollableMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveClampScrollableMethod "getTighteningThreshold" o = ClampScrollableGetTighteningThresholdMethodInfo
    ResolveClampScrollableMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveClampScrollableMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveClampScrollableMethod "getVadjustment" o = Gtk.Scrollable.ScrollableGetVadjustmentMethodInfo
    ResolveClampScrollableMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveClampScrollableMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveClampScrollableMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveClampScrollableMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveClampScrollableMethod "getVscrollPolicy" o = Gtk.Scrollable.ScrollableGetVscrollPolicyMethodInfo
    ResolveClampScrollableMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveClampScrollableMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
    ResolveClampScrollableMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveClampScrollableMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveClampScrollableMethod "setChild" o = ClampScrollableSetChildMethodInfo
    ResolveClampScrollableMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveClampScrollableMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveClampScrollableMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveClampScrollableMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveClampScrollableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveClampScrollableMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveClampScrollableMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveClampScrollableMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveClampScrollableMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveClampScrollableMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveClampScrollableMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveClampScrollableMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveClampScrollableMethod "setHadjustment" o = Gtk.Scrollable.ScrollableSetHadjustmentMethodInfo
    ResolveClampScrollableMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveClampScrollableMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveClampScrollableMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveClampScrollableMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveClampScrollableMethod "setHscrollPolicy" o = Gtk.Scrollable.ScrollableSetHscrollPolicyMethodInfo
    ResolveClampScrollableMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveClampScrollableMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveClampScrollableMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveClampScrollableMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveClampScrollableMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveClampScrollableMethod "setMaximumSize" o = ClampScrollableSetMaximumSizeMethodInfo
    ResolveClampScrollableMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveClampScrollableMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveClampScrollableMethod "setOrientation" o = Gtk.Orientable.OrientableSetOrientationMethodInfo
    ResolveClampScrollableMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveClampScrollableMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveClampScrollableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveClampScrollableMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveClampScrollableMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveClampScrollableMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveClampScrollableMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveClampScrollableMethod "setTighteningThreshold" o = ClampScrollableSetTighteningThresholdMethodInfo
    ResolveClampScrollableMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveClampScrollableMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveClampScrollableMethod "setVadjustment" o = Gtk.Scrollable.ScrollableSetVadjustmentMethodInfo
    ResolveClampScrollableMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveClampScrollableMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveClampScrollableMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveClampScrollableMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveClampScrollableMethod "setVscrollPolicy" o = Gtk.Scrollable.ScrollableSetVscrollPolicyMethodInfo
    ResolveClampScrollableMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveClampScrollableMethod t ClampScrollable, O.OverloadedMethod info ClampScrollable p) => OL.IsLabel t (ClampScrollable -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveClampScrollableMethod t ClampScrollable, O.OverloadedMethod info ClampScrollable p, R.HasField t ClampScrollable p) => R.HasField t ClampScrollable p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveClampScrollableMethod t ClampScrollable, O.OverloadedMethodInfo info ClampScrollable) => OL.IsLabel t (O.MethodProxy info ClampScrollable) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- VVV Prop "child"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@child@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' clampScrollable #child
-- @
getClampScrollableChild :: (MonadIO m, IsClampScrollable o) => o -> m (Maybe Gtk.Widget.Widget)
getClampScrollableChild :: forall (m :: * -> *) o.
(MonadIO m, IsClampScrollable o) =>
o -> m (Maybe Widget)
getClampScrollableChild o
obj = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Widget -> Widget) -> IO (Maybe Widget)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"child" ManagedPtr Widget -> Widget
Gtk.Widget.Widget

-- | Set the value of the “@child@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' clampScrollable [ #child 'Data.GI.Base.Attributes.:=' value ]
-- @
setClampScrollableChild :: (MonadIO m, IsClampScrollable o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setClampScrollableChild :: forall (m :: * -> *) o a.
(MonadIO m, IsClampScrollable o, IsWidget a) =>
o -> a -> m ()
setClampScrollableChild o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"child" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@child@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructClampScrollableChild :: (IsClampScrollable o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructClampScrollableChild :: forall o (m :: * -> *) a.
(IsClampScrollable o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructClampScrollableChild a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"child" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@child@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #child
-- @
clearClampScrollableChild :: (MonadIO m, IsClampScrollable o) => o -> m ()
clearClampScrollableChild :: forall (m :: * -> *) o.
(MonadIO m, IsClampScrollable o) =>
o -> m ()
clearClampScrollableChild o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"child" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data ClampScrollableChildPropertyInfo
instance AttrInfo ClampScrollableChildPropertyInfo where
    type AttrAllowedOps ClampScrollableChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ClampScrollableChildPropertyInfo = IsClampScrollable
    type AttrSetTypeConstraint ClampScrollableChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint ClampScrollableChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType ClampScrollableChildPropertyInfo = Gtk.Widget.Widget
    type AttrGetType ClampScrollableChildPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel ClampScrollableChildPropertyInfo = "child"
    type AttrOrigin ClampScrollableChildPropertyInfo = ClampScrollable
    attrGet = getClampScrollableChild
    attrSet = setClampScrollableChild
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructClampScrollableChild
    attrClear = clearClampScrollableChild
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ClampScrollable.child"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.6/docs/GI-Adw-Objects-ClampScrollable.html#g:attr:child"
        })
#endif

-- VVV Prop "maximum-size"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@maximum-size@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' clampScrollable #maximumSize
-- @
getClampScrollableMaximumSize :: (MonadIO m, IsClampScrollable o) => o -> m Int32
getClampScrollableMaximumSize :: forall (m :: * -> *) o.
(MonadIO m, IsClampScrollable o) =>
o -> m Int32
getClampScrollableMaximumSize o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"maximum-size"

-- | Set the value of the “@maximum-size@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' clampScrollable [ #maximumSize 'Data.GI.Base.Attributes.:=' value ]
-- @
setClampScrollableMaximumSize :: (MonadIO m, IsClampScrollable o) => o -> Int32 -> m ()
setClampScrollableMaximumSize :: forall (m :: * -> *) o.
(MonadIO m, IsClampScrollable o) =>
o -> Int32 -> m ()
setClampScrollableMaximumSize o
obj Int32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"maximum-size" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@maximum-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructClampScrollableMaximumSize :: (IsClampScrollable o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructClampScrollableMaximumSize :: forall o (m :: * -> *).
(IsClampScrollable o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructClampScrollableMaximumSize Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"maximum-size" Int32
val

#if defined(ENABLE_OVERLOADING)
data ClampScrollableMaximumSizePropertyInfo
instance AttrInfo ClampScrollableMaximumSizePropertyInfo where
    type AttrAllowedOps ClampScrollableMaximumSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ClampScrollableMaximumSizePropertyInfo = IsClampScrollable
    type AttrSetTypeConstraint ClampScrollableMaximumSizePropertyInfo = (~) Int32
    type AttrTransferTypeConstraint ClampScrollableMaximumSizePropertyInfo = (~) Int32
    type AttrTransferType ClampScrollableMaximumSizePropertyInfo = Int32
    type AttrGetType ClampScrollableMaximumSizePropertyInfo = Int32
    type AttrLabel ClampScrollableMaximumSizePropertyInfo = "maximum-size"
    type AttrOrigin ClampScrollableMaximumSizePropertyInfo = ClampScrollable
    attrGet = getClampScrollableMaximumSize
    attrSet = setClampScrollableMaximumSize
    attrTransfer _ v = do
        return v
    attrConstruct = constructClampScrollableMaximumSize
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ClampScrollable.maximumSize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.6/docs/GI-Adw-Objects-ClampScrollable.html#g:attr:maximumSize"
        })
#endif

-- VVV Prop "tightening-threshold"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@tightening-threshold@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' clampScrollable #tighteningThreshold
-- @
getClampScrollableTighteningThreshold :: (MonadIO m, IsClampScrollable o) => o -> m Int32
getClampScrollableTighteningThreshold :: forall (m :: * -> *) o.
(MonadIO m, IsClampScrollable o) =>
o -> m Int32
getClampScrollableTighteningThreshold o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"tightening-threshold"

-- | Set the value of the “@tightening-threshold@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' clampScrollable [ #tighteningThreshold 'Data.GI.Base.Attributes.:=' value ]
-- @
setClampScrollableTighteningThreshold :: (MonadIO m, IsClampScrollable o) => o -> Int32 -> m ()
setClampScrollableTighteningThreshold :: forall (m :: * -> *) o.
(MonadIO m, IsClampScrollable o) =>
o -> Int32 -> m ()
setClampScrollableTighteningThreshold o
obj Int32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"tightening-threshold" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@tightening-threshold@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructClampScrollableTighteningThreshold :: (IsClampScrollable o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructClampScrollableTighteningThreshold :: forall o (m :: * -> *).
(IsClampScrollable o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructClampScrollableTighteningThreshold Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"tightening-threshold" Int32
val

#if defined(ENABLE_OVERLOADING)
data ClampScrollableTighteningThresholdPropertyInfo
instance AttrInfo ClampScrollableTighteningThresholdPropertyInfo where
    type AttrAllowedOps ClampScrollableTighteningThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ClampScrollableTighteningThresholdPropertyInfo = IsClampScrollable
    type AttrSetTypeConstraint ClampScrollableTighteningThresholdPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint ClampScrollableTighteningThresholdPropertyInfo = (~) Int32
    type AttrTransferType ClampScrollableTighteningThresholdPropertyInfo = Int32
    type AttrGetType ClampScrollableTighteningThresholdPropertyInfo = Int32
    type AttrLabel ClampScrollableTighteningThresholdPropertyInfo = "tightening-threshold"
    type AttrOrigin ClampScrollableTighteningThresholdPropertyInfo = ClampScrollable
    attrGet = getClampScrollableTighteningThreshold
    attrSet = setClampScrollableTighteningThreshold
    attrTransfer _ v = do
        return v
    attrConstruct = constructClampScrollableTighteningThreshold
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ClampScrollable.tighteningThreshold"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.6/docs/GI-Adw-Objects-ClampScrollable.html#g:attr:tighteningThreshold"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ClampScrollable
type instance O.AttributeList ClampScrollable = ClampScrollableAttributeList
type ClampScrollableAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", ClampScrollableChildPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("hadjustment", Gtk.Scrollable.ScrollableHadjustmentPropertyInfo), '("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), '("hscrollPolicy", Gtk.Scrollable.ScrollableHscrollPolicyPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("maximumSize", ClampScrollableMaximumSizePropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("orientation", Gtk.Orientable.OrientableOrientationPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("tighteningThreshold", ClampScrollableTighteningThresholdPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("vadjustment", Gtk.Scrollable.ScrollableVadjustmentPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("vscrollPolicy", Gtk.Scrollable.ScrollableVscrollPolicyPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
clampScrollableChild :: AttrLabelProxy "child"
clampScrollableChild = AttrLabelProxy

clampScrollableMaximumSize :: AttrLabelProxy "maximumSize"
clampScrollableMaximumSize = AttrLabelProxy

clampScrollableTighteningThreshold :: AttrLabelProxy "tighteningThreshold"
clampScrollableTighteningThreshold = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ClampScrollable = ClampScrollableSignalList
type ClampScrollableSignalList = ('[ '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method ClampScrollable::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Adw" , name = "ClampScrollable" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_clamp_scrollable_new" adw_clamp_scrollable_new :: 
    IO (Ptr ClampScrollable)

-- | Creates a new @AdwClampScrollable@.
clampScrollableNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ClampScrollable
    -- ^ __Returns:__ the newly created @AdwClampScrollable@
clampScrollableNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m ClampScrollable
clampScrollableNew  = IO ClampScrollable -> m ClampScrollable
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ClampScrollable -> m ClampScrollable)
-> IO ClampScrollable -> m ClampScrollable
forall a b. (a -> b) -> a -> b
$ do
    Ptr ClampScrollable
result <- IO (Ptr ClampScrollable)
adw_clamp_scrollable_new
    Text -> Ptr ClampScrollable -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"clampScrollableNew" Ptr ClampScrollable
result
    ClampScrollable
result' <- ((ManagedPtr ClampScrollable -> ClampScrollable)
-> Ptr ClampScrollable -> IO ClampScrollable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ClampScrollable -> ClampScrollable
ClampScrollable) Ptr ClampScrollable
result
    ClampScrollable -> IO ClampScrollable
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ClampScrollable
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method ClampScrollable::get_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ClampScrollable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a clamp scrollable" , 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 "adw_clamp_scrollable_get_child" adw_clamp_scrollable_get_child :: 
    Ptr ClampScrollable ->                  -- self : TInterface (Name {namespace = "Adw", name = "ClampScrollable"})
    IO (Ptr Gtk.Widget.Widget)

-- | Gets the child widget of /@self@/.
clampScrollableGetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsClampScrollable a) =>
    a
    -- ^ /@self@/: a clamp scrollable
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the child widget of /@self@/
clampScrollableGetChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClampScrollable a) =>
a -> m (Maybe Widget)
clampScrollableGetChild a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ClampScrollable
self' <- a -> IO (Ptr ClampScrollable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr ClampScrollable -> IO (Ptr Widget)
adw_clamp_scrollable_get_child Ptr ClampScrollable
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(ENABLE_OVERLOADING)
data ClampScrollableGetChildMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsClampScrollable a) => O.OverloadedMethod ClampScrollableGetChildMethodInfo a signature where
    overloadedMethod = clampScrollableGetChild

instance O.OverloadedMethodInfo ClampScrollableGetChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ClampScrollable.clampScrollableGetChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.6/docs/GI-Adw-Objects-ClampScrollable.html#v:clampScrollableGetChild"
        })


#endif

-- method ClampScrollable::get_maximum_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ClampScrollable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a clamp scrollable" , 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 "adw_clamp_scrollable_get_maximum_size" adw_clamp_scrollable_get_maximum_size :: 
    Ptr ClampScrollable ->                  -- self : TInterface (Name {namespace = "Adw", name = "ClampScrollable"})
    IO Int32

-- | Gets the maximum size allocated to the child.
clampScrollableGetMaximumSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsClampScrollable a) =>
    a
    -- ^ /@self@/: a clamp scrollable
    -> m Int32
    -- ^ __Returns:__ the maximum size to allocate to the child
clampScrollableGetMaximumSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClampScrollable a) =>
a -> m Int32
clampScrollableGetMaximumSize a
self = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr ClampScrollable
self' <- a -> IO (Ptr ClampScrollable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr ClampScrollable -> IO Int32
adw_clamp_scrollable_get_maximum_size Ptr ClampScrollable
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ClampScrollableGetMaximumSizeMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsClampScrollable a) => O.OverloadedMethod ClampScrollableGetMaximumSizeMethodInfo a signature where
    overloadedMethod = clampScrollableGetMaximumSize

instance O.OverloadedMethodInfo ClampScrollableGetMaximumSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ClampScrollable.clampScrollableGetMaximumSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.6/docs/GI-Adw-Objects-ClampScrollable.html#v:clampScrollableGetMaximumSize"
        })


#endif

-- method ClampScrollable::get_tightening_threshold
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ClampScrollable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a clamp scrollable" , 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 "adw_clamp_scrollable_get_tightening_threshold" adw_clamp_scrollable_get_tightening_threshold :: 
    Ptr ClampScrollable ->                  -- self : TInterface (Name {namespace = "Adw", name = "ClampScrollable"})
    IO Int32

-- | Gets the size above which the child is clamped.
clampScrollableGetTighteningThreshold ::
    (B.CallStack.HasCallStack, MonadIO m, IsClampScrollable a) =>
    a
    -- ^ /@self@/: a clamp scrollable
    -> m Int32
    -- ^ __Returns:__ the size above which the child is clamped
clampScrollableGetTighteningThreshold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClampScrollable a) =>
a -> m Int32
clampScrollableGetTighteningThreshold a
self = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr ClampScrollable
self' <- a -> IO (Ptr ClampScrollable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr ClampScrollable -> IO Int32
adw_clamp_scrollable_get_tightening_threshold Ptr ClampScrollable
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ClampScrollableGetTighteningThresholdMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsClampScrollable a) => O.OverloadedMethod ClampScrollableGetTighteningThresholdMethodInfo a signature where
    overloadedMethod = clampScrollableGetTighteningThreshold

instance O.OverloadedMethodInfo ClampScrollableGetTighteningThresholdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ClampScrollable.clampScrollableGetTighteningThreshold",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.6/docs/GI-Adw-Objects-ClampScrollable.html#v:clampScrollableGetTighteningThreshold"
        })


#endif

-- method ClampScrollable::set_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ClampScrollable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a clamp scrollable" , 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 = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the child widget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_clamp_scrollable_set_child" adw_clamp_scrollable_set_child :: 
    Ptr ClampScrollable ->                  -- self : TInterface (Name {namespace = "Adw", name = "ClampScrollable"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the child widget of /@self@/.
clampScrollableSetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsClampScrollable a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a clamp scrollable
    -> Maybe (b)
    -- ^ /@child@/: the child widget
    -> m ()
clampScrollableSetChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClampScrollable a, IsWidget b) =>
a -> Maybe b -> m ()
clampScrollableSetChild a
self Maybe b
child = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ClampScrollable
self' <- a -> IO (Ptr ClampScrollable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeChild <- case Maybe b
child of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jChild -> do
            Ptr Widget
jChild' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jChild
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jChild'
    Ptr ClampScrollable -> Ptr Widget -> IO ()
adw_clamp_scrollable_set_child Ptr ClampScrollable
self' Ptr Widget
maybeChild
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
child b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ClampScrollableSetChildMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsClampScrollable a, Gtk.Widget.IsWidget b) => O.OverloadedMethod ClampScrollableSetChildMethodInfo a signature where
    overloadedMethod = clampScrollableSetChild

instance O.OverloadedMethodInfo ClampScrollableSetChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ClampScrollable.clampScrollableSetChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.6/docs/GI-Adw-Objects-ClampScrollable.html#v:clampScrollableSetChild"
        })


#endif

-- method ClampScrollable::set_maximum_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ClampScrollable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a clamp scrollable" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "maximum_size"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the maximum size" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_clamp_scrollable_set_maximum_size" adw_clamp_scrollable_set_maximum_size :: 
    Ptr ClampScrollable ->                  -- self : TInterface (Name {namespace = "Adw", name = "ClampScrollable"})
    Int32 ->                                -- maximum_size : TBasicType TInt
    IO ()

-- | Sets the maximum size allocated to the child.
-- 
-- It is the width if the clamp is horizontal, or the height if it is vertical.
clampScrollableSetMaximumSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsClampScrollable a) =>
    a
    -- ^ /@self@/: a clamp scrollable
    -> Int32
    -- ^ /@maximumSize@/: the maximum size
    -> m ()
clampScrollableSetMaximumSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClampScrollable a) =>
a -> Int32 -> m ()
clampScrollableSetMaximumSize a
self Int32
maximumSize = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ClampScrollable
self' <- a -> IO (Ptr ClampScrollable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ClampScrollable -> Int32 -> IO ()
adw_clamp_scrollable_set_maximum_size Ptr ClampScrollable
self' Int32
maximumSize
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ClampScrollableSetMaximumSizeMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsClampScrollable a) => O.OverloadedMethod ClampScrollableSetMaximumSizeMethodInfo a signature where
    overloadedMethod = clampScrollableSetMaximumSize

instance O.OverloadedMethodInfo ClampScrollableSetMaximumSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ClampScrollable.clampScrollableSetMaximumSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.6/docs/GI-Adw-Objects-ClampScrollable.html#v:clampScrollableSetMaximumSize"
        })


#endif

-- method ClampScrollable::set_tightening_threshold
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ClampScrollable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a clamp scrollable" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tightening_threshold"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the tightening threshold"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_clamp_scrollable_set_tightening_threshold" adw_clamp_scrollable_set_tightening_threshold :: 
    Ptr ClampScrollable ->                  -- self : TInterface (Name {namespace = "Adw", name = "ClampScrollable"})
    Int32 ->                                -- tightening_threshold : TBasicType TInt
    IO ()

-- | Sets the size above which the child is clamped.
-- 
-- Starting from this size, the clamp will tighten its grip on the child, slowly
-- allocating less and less of the available size up to the maximum allocated
-- size. Below that threshold and below the maximum width, the child will be
-- allocated all the available size.
-- 
-- If the threshold is greater than the maximum size to allocate to the child,
-- the child will be allocated all the width up to the maximum. If the threshold
-- is lower than the minimum size to allocate to the child, that size will be
-- used as the tightening threshold.
-- 
-- Effectively, tightening the grip on the child before it reaches its maximum
-- size makes transitions to and from the maximum size smoother when resizing.
clampScrollableSetTighteningThreshold ::
    (B.CallStack.HasCallStack, MonadIO m, IsClampScrollable a) =>
    a
    -- ^ /@self@/: a clamp scrollable
    -> Int32
    -- ^ /@tighteningThreshold@/: the tightening threshold
    -> m ()
clampScrollableSetTighteningThreshold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClampScrollable a) =>
a -> Int32 -> m ()
clampScrollableSetTighteningThreshold a
self Int32
tighteningThreshold = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ClampScrollable
self' <- a -> IO (Ptr ClampScrollable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ClampScrollable -> Int32 -> IO ()
adw_clamp_scrollable_set_tightening_threshold Ptr ClampScrollable
self' Int32
tighteningThreshold
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ClampScrollableSetTighteningThresholdMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsClampScrollable a) => O.OverloadedMethod ClampScrollableSetTighteningThresholdMethodInfo a signature where
    overloadedMethod = clampScrollableSetTighteningThreshold

instance O.OverloadedMethodInfo ClampScrollableSetTighteningThresholdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ClampScrollable.clampScrollableSetTighteningThreshold",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.6/docs/GI-Adw-Objects-ClampScrollable.html#v:clampScrollableSetTighteningThreshold"
        })


#endif