{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A best fit container.
-- 
-- The @AdwSqueezer@ widget is a container which only shows the first of its
-- children that fits in the available size. It is convenient to offer different
-- widgets to represent the same data with different levels of detail, making
-- the widget seem to squeeze itself to fit in the available space.
-- 
-- Transitions between children can be animated as fades. This can be controlled
-- with [Squeezer:transitionType]("GI.Adw.Objects.Squeezer#g:attr:transitionType").
-- 
-- == CSS nodes
-- 
-- @AdwSqueezer@ has a single CSS node with name @squeezer@.
-- 
-- /Since: 1.0/

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

module GI.Adw.Objects.Squeezer
    ( 

-- * Exported types
    Squeezer(..)                            ,
    IsSqueezer                              ,
    toSqueezer                              ,


 -- * 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"), [add]("GI.Adw.Objects.Squeezer#g:method:add"), [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"), [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"), [remove]("GI.Adw.Objects.Squeezer#g:method:remove"), [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"), [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
-- [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"), [getAllowNone]("GI.Adw.Objects.Squeezer#g:method:getAllowNone"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [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"), [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"), [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"), [getHomogeneous]("GI.Adw.Objects.Squeezer#g:method:getHomogeneous"), [getInterpolateSize]("GI.Adw.Objects.Squeezer#g:method:getInterpolateSize"), [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"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [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"), [getPage]("GI.Adw.Objects.Squeezer#g:method:getPage"), [getPages]("GI.Adw.Objects.Squeezer#g:method:getPages"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [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"), [getSwitchThresholdPolicy]("GI.Adw.Objects.Squeezer#g:method:getSwitchThresholdPolicy"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTransitionDuration]("GI.Adw.Objects.Squeezer#g:method:getTransitionDuration"), [getTransitionRunning]("GI.Adw.Objects.Squeezer#g:method:getTransitionRunning"), [getTransitionType]("GI.Adw.Objects.Squeezer#g:method:getTransitionType"), [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"), [getVisibleChild]("GI.Adw.Objects.Squeezer#g:method:getVisibleChild"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth"), [getXalign]("GI.Adw.Objects.Squeezer#g:method:getXalign"), [getYalign]("GI.Adw.Objects.Squeezer#g:method:getYalign").
-- 
-- ==== Setters
-- [setAllowNone]("GI.Adw.Objects.Squeezer#g:method:setAllowNone"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [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"), [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"), [setHomogeneous]("GI.Adw.Objects.Squeezer#g:method:setHomogeneous"), [setInterpolateSize]("GI.Adw.Objects.Squeezer#g:method:setInterpolateSize"), [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"), [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"), [setSwitchThresholdPolicy]("GI.Adw.Objects.Squeezer#g:method:setSwitchThresholdPolicy"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTransitionDuration]("GI.Adw.Objects.Squeezer#g:method:setTransitionDuration"), [setTransitionType]("GI.Adw.Objects.Squeezer#g:method:setTransitionType"), [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"), [setXalign]("GI.Adw.Objects.Squeezer#g:method:setXalign"), [setYalign]("GI.Adw.Objects.Squeezer#g:method:setYalign").

#if defined(ENABLE_OVERLOADING)
    ResolveSqueezerMethod                   ,
#endif

-- ** add #method:add#

#if defined(ENABLE_OVERLOADING)
    SqueezerAddMethodInfo                   ,
#endif
    squeezerAdd                             ,


-- ** getAllowNone #method:getAllowNone#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetAllowNoneMethodInfo          ,
#endif
    squeezerGetAllowNone                    ,


-- ** getHomogeneous #method:getHomogeneous#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetHomogeneousMethodInfo        ,
#endif
    squeezerGetHomogeneous                  ,


-- ** getInterpolateSize #method:getInterpolateSize#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetInterpolateSizeMethodInfo    ,
#endif
    squeezerGetInterpolateSize              ,


-- ** getPage #method:getPage#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetPageMethodInfo               ,
#endif
    squeezerGetPage                         ,


-- ** getPages #method:getPages#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetPagesMethodInfo              ,
#endif
    squeezerGetPages                        ,


-- ** getSwitchThresholdPolicy #method:getSwitchThresholdPolicy#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetSwitchThresholdPolicyMethodInfo,
#endif
    squeezerGetSwitchThresholdPolicy        ,


-- ** getTransitionDuration #method:getTransitionDuration#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetTransitionDurationMethodInfo ,
#endif
    squeezerGetTransitionDuration           ,


-- ** getTransitionRunning #method:getTransitionRunning#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetTransitionRunningMethodInfo  ,
#endif
    squeezerGetTransitionRunning            ,


-- ** getTransitionType #method:getTransitionType#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetTransitionTypeMethodInfo     ,
#endif
    squeezerGetTransitionType               ,


-- ** getVisibleChild #method:getVisibleChild#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetVisibleChildMethodInfo       ,
#endif
    squeezerGetVisibleChild                 ,


-- ** getXalign #method:getXalign#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetXalignMethodInfo             ,
#endif
    squeezerGetXalign                       ,


-- ** getYalign #method:getYalign#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetYalignMethodInfo             ,
#endif
    squeezerGetYalign                       ,


-- ** new #method:new#

    squeezerNew                             ,


-- ** remove #method:remove#

#if defined(ENABLE_OVERLOADING)
    SqueezerRemoveMethodInfo                ,
#endif
    squeezerRemove                          ,


-- ** setAllowNone #method:setAllowNone#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetAllowNoneMethodInfo          ,
#endif
    squeezerSetAllowNone                    ,


-- ** setHomogeneous #method:setHomogeneous#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetHomogeneousMethodInfo        ,
#endif
    squeezerSetHomogeneous                  ,


-- ** setInterpolateSize #method:setInterpolateSize#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetInterpolateSizeMethodInfo    ,
#endif
    squeezerSetInterpolateSize              ,


-- ** setSwitchThresholdPolicy #method:setSwitchThresholdPolicy#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetSwitchThresholdPolicyMethodInfo,
#endif
    squeezerSetSwitchThresholdPolicy        ,


-- ** setTransitionDuration #method:setTransitionDuration#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetTransitionDurationMethodInfo ,
#endif
    squeezerSetTransitionDuration           ,


-- ** setTransitionType #method:setTransitionType#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetTransitionTypeMethodInfo     ,
#endif
    squeezerSetTransitionType               ,


-- ** setXalign #method:setXalign#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetXalignMethodInfo             ,
#endif
    squeezerSetXalign                       ,


-- ** setYalign #method:setYalign#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetYalignMethodInfo             ,
#endif
    squeezerSetYalign                       ,




 -- * Properties


-- ** allowNone #attr:allowNone#
-- | Whether to allow squeezing beyond the last child\'s minimum size.
-- 
-- If set to @TRUE@, the squeezer can shrink to the point where no child can
-- be shown. This is functionally equivalent to appending a widget with 0x0
-- minimum size.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerAllowNonePropertyInfo           ,
#endif
    constructSqueezerAllowNone              ,
    getSqueezerAllowNone                    ,
    setSqueezerAllowNone                    ,
#if defined(ENABLE_OVERLOADING)
    squeezerAllowNone                       ,
#endif


-- ** homogeneous #attr:homogeneous#
-- | Whether all children have the same size for the opposite orientation.
-- 
-- For example, if a squeezer is horizontal and is homogeneous, it will request
-- the same height for all its children. If it isn\'t, the squeezer may change
-- size when a different child becomes visible.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerHomogeneousPropertyInfo         ,
#endif
    constructSqueezerHomogeneous            ,
    getSqueezerHomogeneous                  ,
    setSqueezerHomogeneous                  ,
#if defined(ENABLE_OVERLOADING)
    squeezerHomogeneous                     ,
#endif


-- ** interpolateSize #attr:interpolateSize#
-- | Whether the squeezer interpolates its size when changing the visible child.
-- 
-- If @TRUE@, the squeezer will interpolate its size between the one of the
-- previous visible child and the one of the new visible child, according to
-- the set transition duration and the orientation, e.g. if the squeezer is
-- horizontal, it will interpolate the its height.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerInterpolateSizePropertyInfo     ,
#endif
    constructSqueezerInterpolateSize        ,
    getSqueezerInterpolateSize              ,
    setSqueezerInterpolateSize              ,
#if defined(ENABLE_OVERLOADING)
    squeezerInterpolateSize                 ,
#endif


-- ** pages #attr:pages#
-- | A selection model with the squeezer\'s pages.
-- 
-- This can be used to keep an up-to-date view. The model also implements
-- t'GI.Gtk.Interfaces.SelectionModel.SelectionModel' and can be used to track the visible page.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerPagesPropertyInfo               ,
#endif
    getSqueezerPages                        ,
#if defined(ENABLE_OVERLOADING)
    squeezerPages                           ,
#endif


-- ** switchThresholdPolicy #attr:switchThresholdPolicy#
-- | Determines when the squeezer will switch children.
-- 
-- If set to @ADW_FOLD_THRESHOLD_POLICY_MINIMUM@, it will only switch when
-- the visible child cannot fit anymore. With
-- @ADW_FOLD_THRESHOLD_POLICY_NATURAL@, it will switch as soon as the visible
-- child doesn\'t get their natural size.
-- 
-- This can be useful if you have a long ellipsizing label and want to let it
-- ellipsize instead of immediately switching.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerSwitchThresholdPolicyPropertyInfo,
#endif
    constructSqueezerSwitchThresholdPolicy  ,
    getSqueezerSwitchThresholdPolicy        ,
    setSqueezerSwitchThresholdPolicy        ,
#if defined(ENABLE_OVERLOADING)
    squeezerSwitchThresholdPolicy           ,
#endif


-- ** transitionDuration #attr:transitionDuration#
-- | The animation duration, in milliseconds.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerTransitionDurationPropertyInfo  ,
#endif
    constructSqueezerTransitionDuration     ,
    getSqueezerTransitionDuration           ,
    setSqueezerTransitionDuration           ,
#if defined(ENABLE_OVERLOADING)
    squeezerTransitionDuration              ,
#endif


-- ** transitionRunning #attr:transitionRunning#
-- | Whether a transition is currently running.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerTransitionRunningPropertyInfo   ,
#endif
    getSqueezerTransitionRunning            ,
#if defined(ENABLE_OVERLOADING)
    squeezerTransitionRunning               ,
#endif


-- ** transitionType #attr:transitionType#
-- | The type of animation used for transitions between children.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerTransitionTypePropertyInfo      ,
#endif
    constructSqueezerTransitionType         ,
    getSqueezerTransitionType               ,
    setSqueezerTransitionType               ,
#if defined(ENABLE_OVERLOADING)
    squeezerTransitionType                  ,
#endif


-- ** visibleChild #attr:visibleChild#
-- | The currently visible child.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerVisibleChildPropertyInfo        ,
#endif
    getSqueezerVisibleChild                 ,
#if defined(ENABLE_OVERLOADING)
    squeezerVisibleChild                    ,
#endif


-- ** xalign #attr:xalign#
-- | The horizontal alignment, from 0 (start) to 1 (end).
-- 
-- This affects the children allocation during transitions, when they exceed
-- the size of the squeezer.
-- 
-- For example, 0.5 means the child will be centered, 0 means it will keep the
-- start side aligned and overflow the end side, and 1 means the opposite.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerXalignPropertyInfo              ,
#endif
    constructSqueezerXalign                 ,
    getSqueezerXalign                       ,
    setSqueezerXalign                       ,
#if defined(ENABLE_OVERLOADING)
    squeezerXalign                          ,
#endif


-- ** yalign #attr:yalign#
-- | The vertical alignment, from 0 (top) to 1 (bottom).
-- 
-- This affects the children allocation during transitions, when they exceed
-- the size of the squeezer.
-- 
-- For example, 0.5 means the child will be centered, 0 means it will keep the
-- top side aligned and overflow the bottom side, and 1 means the opposite.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerYalignPropertyInfo              ,
#endif
    constructSqueezerYalign                 ,
    getSqueezerYalign                       ,
    setSqueezerYalign                       ,
#if defined(ENABLE_OVERLOADING)
    squeezerYalign                          ,
#endif




    ) 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.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.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 {-# SOURCE #-} qualified GI.Adw.Enums as Adw.Enums
import {-# SOURCE #-} qualified GI.Adw.Objects.SqueezerPage as Adw.SqueezerPage
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.SelectionModel as Gtk.SelectionModel
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

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

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

foreign import ccall "adw_squeezer_get_type"
    c_adw_squeezer_get_type :: IO B.Types.GType

instance B.Types.TypedObject Squeezer where
    glibType :: IO GType
glibType = IO GType
c_adw_squeezer_get_type

instance B.Types.GObject Squeezer

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

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

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

-- | Convert 'Squeezer' 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 Squeezer) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_adw_squeezer_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Squeezer -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Squeezer
P.Nothing = Ptr GValue -> Ptr Squeezer -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Squeezer
forall a. Ptr a
FP.nullPtr :: FP.Ptr Squeezer)
    gvalueSet_ Ptr GValue
gv (P.Just Squeezer
obj) = Squeezer -> (Ptr Squeezer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Squeezer
obj (Ptr GValue -> Ptr Squeezer -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Squeezer)
gvalueGet_ Ptr GValue
gv = do
        Ptr Squeezer
ptr <- Ptr GValue -> IO (Ptr Squeezer)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Squeezer)
        if Ptr Squeezer
ptr Ptr Squeezer -> Ptr Squeezer -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Squeezer
forall a. Ptr a
FP.nullPtr
        then Squeezer -> Maybe Squeezer
forall a. a -> Maybe a
P.Just (Squeezer -> Maybe Squeezer) -> IO Squeezer -> IO (Maybe Squeezer)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Squeezer -> Squeezer) -> Ptr Squeezer -> IO Squeezer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Squeezer -> Squeezer
Squeezer Ptr Squeezer
ptr
        else Maybe Squeezer -> IO (Maybe Squeezer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Squeezer
forall a. Maybe a
P.Nothing
        
    

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

instance (info ~ ResolveSqueezerMethod t Squeezer, O.OverloadedMethod info Squeezer p) => OL.IsLabel t (Squeezer -> 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 ~ ResolveSqueezerMethod t Squeezer, O.OverloadedMethod info Squeezer p, R.HasField t Squeezer p) => R.HasField t Squeezer p where
    getField = O.overloadedMethod @info

#endif

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

#endif

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

-- | Get the value of the “@allow-none@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' squeezer #allowNone
-- @
getSqueezerAllowNone :: (MonadIO m, IsSqueezer o) => o -> m Bool
getSqueezerAllowNone :: forall (m :: * -> *) o. (MonadIO m, IsSqueezer o) => o -> m Bool
getSqueezerAllowNone o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"allow-none"

-- | Set the value of the “@allow-none@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' squeezer [ #allowNone 'Data.GI.Base.Attributes.:=' value ]
-- @
setSqueezerAllowNone :: (MonadIO m, IsSqueezer o) => o -> Bool -> m ()
setSqueezerAllowNone :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezer o) =>
o -> Bool -> m ()
setSqueezerAllowNone o
obj Bool
val = IO () -> m ()
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"allow-none" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@allow-none@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSqueezerAllowNone :: (IsSqueezer o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSqueezerAllowNone :: forall o (m :: * -> *).
(IsSqueezer o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSqueezerAllowNone Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"allow-none" Bool
val

#if defined(ENABLE_OVERLOADING)
data SqueezerAllowNonePropertyInfo
instance AttrInfo SqueezerAllowNonePropertyInfo where
    type AttrAllowedOps SqueezerAllowNonePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerAllowNonePropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerAllowNonePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SqueezerAllowNonePropertyInfo = (~) Bool
    type AttrTransferType SqueezerAllowNonePropertyInfo = Bool
    type AttrGetType SqueezerAllowNonePropertyInfo = Bool
    type AttrLabel SqueezerAllowNonePropertyInfo = "allow-none"
    type AttrOrigin SqueezerAllowNonePropertyInfo = Squeezer
    attrGet = getSqueezerAllowNone
    attrSet = setSqueezerAllowNone
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerAllowNone
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Squeezer.allowNone"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-Squeezer.html#g:attr:allowNone"
        })
#endif

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

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

-- | Set the value of the “@homogeneous@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' squeezer [ #homogeneous 'Data.GI.Base.Attributes.:=' value ]
-- @
setSqueezerHomogeneous :: (MonadIO m, IsSqueezer o) => o -> Bool -> m ()
setSqueezerHomogeneous :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezer o) =>
o -> Bool -> m ()
setSqueezerHomogeneous o
obj Bool
val = IO () -> m ()
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"homogeneous" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@homogeneous@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSqueezerHomogeneous :: (IsSqueezer o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSqueezerHomogeneous :: forall o (m :: * -> *).
(IsSqueezer o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSqueezerHomogeneous Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"homogeneous" Bool
val

#if defined(ENABLE_OVERLOADING)
data SqueezerHomogeneousPropertyInfo
instance AttrInfo SqueezerHomogeneousPropertyInfo where
    type AttrAllowedOps SqueezerHomogeneousPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerHomogeneousPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerHomogeneousPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SqueezerHomogeneousPropertyInfo = (~) Bool
    type AttrTransferType SqueezerHomogeneousPropertyInfo = Bool
    type AttrGetType SqueezerHomogeneousPropertyInfo = Bool
    type AttrLabel SqueezerHomogeneousPropertyInfo = "homogeneous"
    type AttrOrigin SqueezerHomogeneousPropertyInfo = Squeezer
    attrGet = getSqueezerHomogeneous
    attrSet = setSqueezerHomogeneous
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerHomogeneous
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Squeezer.homogeneous"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-Squeezer.html#g:attr:homogeneous"
        })
#endif

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

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

-- | Set the value of the “@interpolate-size@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' squeezer [ #interpolateSize 'Data.GI.Base.Attributes.:=' value ]
-- @
setSqueezerInterpolateSize :: (MonadIO m, IsSqueezer o) => o -> Bool -> m ()
setSqueezerInterpolateSize :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezer o) =>
o -> Bool -> m ()
setSqueezerInterpolateSize o
obj Bool
val = IO () -> m ()
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"interpolate-size" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@interpolate-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSqueezerInterpolateSize :: (IsSqueezer o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSqueezerInterpolateSize :: forall o (m :: * -> *).
(IsSqueezer o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSqueezerInterpolateSize Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"interpolate-size" Bool
val

#if defined(ENABLE_OVERLOADING)
data SqueezerInterpolateSizePropertyInfo
instance AttrInfo SqueezerInterpolateSizePropertyInfo where
    type AttrAllowedOps SqueezerInterpolateSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerInterpolateSizePropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerInterpolateSizePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SqueezerInterpolateSizePropertyInfo = (~) Bool
    type AttrTransferType SqueezerInterpolateSizePropertyInfo = Bool
    type AttrGetType SqueezerInterpolateSizePropertyInfo = Bool
    type AttrLabel SqueezerInterpolateSizePropertyInfo = "interpolate-size"
    type AttrOrigin SqueezerInterpolateSizePropertyInfo = Squeezer
    attrGet = getSqueezerInterpolateSize
    attrSet = setSqueezerInterpolateSize
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerInterpolateSize
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Squeezer.interpolateSize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-Squeezer.html#g:attr:interpolateSize"
        })
#endif

-- VVV Prop "pages"
   -- Type: TInterface (Name {namespace = "Gtk", name = "SelectionModel"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data SqueezerPagesPropertyInfo
instance AttrInfo SqueezerPagesPropertyInfo where
    type AttrAllowedOps SqueezerPagesPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SqueezerPagesPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerPagesPropertyInfo = (~) ()
    type AttrTransferTypeConstraint SqueezerPagesPropertyInfo = (~) ()
    type AttrTransferType SqueezerPagesPropertyInfo = ()
    type AttrGetType SqueezerPagesPropertyInfo = (Maybe Gtk.SelectionModel.SelectionModel)
    type AttrLabel SqueezerPagesPropertyInfo = "pages"
    type AttrOrigin SqueezerPagesPropertyInfo = Squeezer
    attrGet = getSqueezerPages
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Squeezer.pages"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-Squeezer.html#g:attr:pages"
        })
#endif

-- VVV Prop "switch-threshold-policy"
   -- Type: TInterface (Name {namespace = "Adw", name = "FoldThresholdPolicy"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@switch-threshold-policy@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' squeezer #switchThresholdPolicy
-- @
getSqueezerSwitchThresholdPolicy :: (MonadIO m, IsSqueezer o) => o -> m Adw.Enums.FoldThresholdPolicy
getSqueezerSwitchThresholdPolicy :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezer o) =>
o -> m FoldThresholdPolicy
getSqueezerSwitchThresholdPolicy o
obj = IO FoldThresholdPolicy -> m FoldThresholdPolicy
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO FoldThresholdPolicy -> m FoldThresholdPolicy)
-> IO FoldThresholdPolicy -> m FoldThresholdPolicy
forall a b. (a -> b) -> a -> b
$ o -> String -> IO FoldThresholdPolicy
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"switch-threshold-policy"

-- | Set the value of the “@switch-threshold-policy@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' squeezer [ #switchThresholdPolicy 'Data.GI.Base.Attributes.:=' value ]
-- @
setSqueezerSwitchThresholdPolicy :: (MonadIO m, IsSqueezer o) => o -> Adw.Enums.FoldThresholdPolicy -> m ()
setSqueezerSwitchThresholdPolicy :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezer o) =>
o -> FoldThresholdPolicy -> m ()
setSqueezerSwitchThresholdPolicy o
obj FoldThresholdPolicy
val = IO () -> m ()
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 -> FoldThresholdPolicy -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"switch-threshold-policy" FoldThresholdPolicy
val

-- | Construct a `GValueConstruct` with valid value for the “@switch-threshold-policy@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSqueezerSwitchThresholdPolicy :: (IsSqueezer o, MIO.MonadIO m) => Adw.Enums.FoldThresholdPolicy -> m (GValueConstruct o)
constructSqueezerSwitchThresholdPolicy :: forall o (m :: * -> *).
(IsSqueezer o, MonadIO m) =>
FoldThresholdPolicy -> m (GValueConstruct o)
constructSqueezerSwitchThresholdPolicy FoldThresholdPolicy
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> FoldThresholdPolicy -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"switch-threshold-policy" FoldThresholdPolicy
val

#if defined(ENABLE_OVERLOADING)
data SqueezerSwitchThresholdPolicyPropertyInfo
instance AttrInfo SqueezerSwitchThresholdPolicyPropertyInfo where
    type AttrAllowedOps SqueezerSwitchThresholdPolicyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerSwitchThresholdPolicyPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerSwitchThresholdPolicyPropertyInfo = (~) Adw.Enums.FoldThresholdPolicy
    type AttrTransferTypeConstraint SqueezerSwitchThresholdPolicyPropertyInfo = (~) Adw.Enums.FoldThresholdPolicy
    type AttrTransferType SqueezerSwitchThresholdPolicyPropertyInfo = Adw.Enums.FoldThresholdPolicy
    type AttrGetType SqueezerSwitchThresholdPolicyPropertyInfo = Adw.Enums.FoldThresholdPolicy
    type AttrLabel SqueezerSwitchThresholdPolicyPropertyInfo = "switch-threshold-policy"
    type AttrOrigin SqueezerSwitchThresholdPolicyPropertyInfo = Squeezer
    attrGet = getSqueezerSwitchThresholdPolicy
    attrSet = setSqueezerSwitchThresholdPolicy
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerSwitchThresholdPolicy
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Squeezer.switchThresholdPolicy"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-Squeezer.html#g:attr:switchThresholdPolicy"
        })
#endif

-- VVV Prop "transition-duration"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@transition-duration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' squeezer #transitionDuration
-- @
getSqueezerTransitionDuration :: (MonadIO m, IsSqueezer o) => o -> m Word32
getSqueezerTransitionDuration :: forall (m :: * -> *) o. (MonadIO m, IsSqueezer o) => o -> m Word32
getSqueezerTransitionDuration o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"transition-duration"

-- | Set the value of the “@transition-duration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' squeezer [ #transitionDuration 'Data.GI.Base.Attributes.:=' value ]
-- @
setSqueezerTransitionDuration :: (MonadIO m, IsSqueezer o) => o -> Word32 -> m ()
setSqueezerTransitionDuration :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezer o) =>
o -> Word32 -> m ()
setSqueezerTransitionDuration o
obj Word32
val = IO () -> m ()
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 -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"transition-duration" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@transition-duration@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSqueezerTransitionDuration :: (IsSqueezer o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructSqueezerTransitionDuration :: forall o (m :: * -> *).
(IsSqueezer o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructSqueezerTransitionDuration Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"transition-duration" Word32
val

#if defined(ENABLE_OVERLOADING)
data SqueezerTransitionDurationPropertyInfo
instance AttrInfo SqueezerTransitionDurationPropertyInfo where
    type AttrAllowedOps SqueezerTransitionDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerTransitionDurationPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerTransitionDurationPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint SqueezerTransitionDurationPropertyInfo = (~) Word32
    type AttrTransferType SqueezerTransitionDurationPropertyInfo = Word32
    type AttrGetType SqueezerTransitionDurationPropertyInfo = Word32
    type AttrLabel SqueezerTransitionDurationPropertyInfo = "transition-duration"
    type AttrOrigin SqueezerTransitionDurationPropertyInfo = Squeezer
    attrGet = getSqueezerTransitionDuration
    attrSet = setSqueezerTransitionDuration
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerTransitionDuration
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Squeezer.transitionDuration"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-Squeezer.html#g:attr:transitionDuration"
        })
#endif

-- VVV Prop "transition-running"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@transition-running@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' squeezer #transitionRunning
-- @
getSqueezerTransitionRunning :: (MonadIO m, IsSqueezer o) => o -> m Bool
getSqueezerTransitionRunning :: forall (m :: * -> *) o. (MonadIO m, IsSqueezer o) => o -> m Bool
getSqueezerTransitionRunning o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"transition-running"

#if defined(ENABLE_OVERLOADING)
data SqueezerTransitionRunningPropertyInfo
instance AttrInfo SqueezerTransitionRunningPropertyInfo where
    type AttrAllowedOps SqueezerTransitionRunningPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint SqueezerTransitionRunningPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerTransitionRunningPropertyInfo = (~) ()
    type AttrTransferTypeConstraint SqueezerTransitionRunningPropertyInfo = (~) ()
    type AttrTransferType SqueezerTransitionRunningPropertyInfo = ()
    type AttrGetType SqueezerTransitionRunningPropertyInfo = Bool
    type AttrLabel SqueezerTransitionRunningPropertyInfo = "transition-running"
    type AttrOrigin SqueezerTransitionRunningPropertyInfo = Squeezer
    attrGet = getSqueezerTransitionRunning
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Squeezer.transitionRunning"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-Squeezer.html#g:attr:transitionRunning"
        })
#endif

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

-- | Get the value of the “@transition-type@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' squeezer #transitionType
-- @
getSqueezerTransitionType :: (MonadIO m, IsSqueezer o) => o -> m Adw.Enums.SqueezerTransitionType
getSqueezerTransitionType :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezer o) =>
o -> m SqueezerTransitionType
getSqueezerTransitionType o
obj = IO SqueezerTransitionType -> m SqueezerTransitionType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO SqueezerTransitionType -> m SqueezerTransitionType)
-> IO SqueezerTransitionType -> m SqueezerTransitionType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO SqueezerTransitionType
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"transition-type"

-- | Set the value of the “@transition-type@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' squeezer [ #transitionType 'Data.GI.Base.Attributes.:=' value ]
-- @
setSqueezerTransitionType :: (MonadIO m, IsSqueezer o) => o -> Adw.Enums.SqueezerTransitionType -> m ()
setSqueezerTransitionType :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezer o) =>
o -> SqueezerTransitionType -> m ()
setSqueezerTransitionType o
obj SqueezerTransitionType
val = IO () -> m ()
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 -> SqueezerTransitionType -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"transition-type" SqueezerTransitionType
val

-- | Construct a `GValueConstruct` with valid value for the “@transition-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSqueezerTransitionType :: (IsSqueezer o, MIO.MonadIO m) => Adw.Enums.SqueezerTransitionType -> m (GValueConstruct o)
constructSqueezerTransitionType :: forall o (m :: * -> *).
(IsSqueezer o, MonadIO m) =>
SqueezerTransitionType -> m (GValueConstruct o)
constructSqueezerTransitionType SqueezerTransitionType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> SqueezerTransitionType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"transition-type" SqueezerTransitionType
val

#if defined(ENABLE_OVERLOADING)
data SqueezerTransitionTypePropertyInfo
instance AttrInfo SqueezerTransitionTypePropertyInfo where
    type AttrAllowedOps SqueezerTransitionTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerTransitionTypePropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerTransitionTypePropertyInfo = (~) Adw.Enums.SqueezerTransitionType
    type AttrTransferTypeConstraint SqueezerTransitionTypePropertyInfo = (~) Adw.Enums.SqueezerTransitionType
    type AttrTransferType SqueezerTransitionTypePropertyInfo = Adw.Enums.SqueezerTransitionType
    type AttrGetType SqueezerTransitionTypePropertyInfo = Adw.Enums.SqueezerTransitionType
    type AttrLabel SqueezerTransitionTypePropertyInfo = "transition-type"
    type AttrOrigin SqueezerTransitionTypePropertyInfo = Squeezer
    attrGet = getSqueezerTransitionType
    attrSet = setSqueezerTransitionType
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerTransitionType
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Squeezer.transitionType"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-Squeezer.html#g:attr:transitionType"
        })
#endif

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

-- | Get the value of the “@visible-child@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' squeezer #visibleChild
-- @
getSqueezerVisibleChild :: (MonadIO m, IsSqueezer o) => o -> m (Maybe Gtk.Widget.Widget)
getSqueezerVisibleChild :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezer o) =>
o -> m (Maybe Widget)
getSqueezerVisibleChild o
obj = IO (Maybe Widget) -> m (Maybe Widget)
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
"visible-child" ManagedPtr Widget -> Widget
Gtk.Widget.Widget

#if defined(ENABLE_OVERLOADING)
data SqueezerVisibleChildPropertyInfo
instance AttrInfo SqueezerVisibleChildPropertyInfo where
    type AttrAllowedOps SqueezerVisibleChildPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SqueezerVisibleChildPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerVisibleChildPropertyInfo = (~) ()
    type AttrTransferTypeConstraint SqueezerVisibleChildPropertyInfo = (~) ()
    type AttrTransferType SqueezerVisibleChildPropertyInfo = ()
    type AttrGetType SqueezerVisibleChildPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel SqueezerVisibleChildPropertyInfo = "visible-child"
    type AttrOrigin SqueezerVisibleChildPropertyInfo = Squeezer
    attrGet = getSqueezerVisibleChild
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Squeezer.visibleChild"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-Squeezer.html#g:attr:visibleChild"
        })
#endif

-- VVV Prop "xalign"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

-- | Set the value of the “@xalign@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' squeezer [ #xalign 'Data.GI.Base.Attributes.:=' value ]
-- @
setSqueezerXalign :: (MonadIO m, IsSqueezer o) => o -> Float -> m ()
setSqueezerXalign :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezer o) =>
o -> Float -> m ()
setSqueezerXalign o
obj Float
val = IO () -> m ()
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 -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"xalign" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@xalign@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSqueezerXalign :: (IsSqueezer o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructSqueezerXalign :: forall o (m :: * -> *).
(IsSqueezer o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructSqueezerXalign Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"xalign" Float
val

#if defined(ENABLE_OVERLOADING)
data SqueezerXalignPropertyInfo
instance AttrInfo SqueezerXalignPropertyInfo where
    type AttrAllowedOps SqueezerXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerXalignPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerXalignPropertyInfo = (~) Float
    type AttrTransferTypeConstraint SqueezerXalignPropertyInfo = (~) Float
    type AttrTransferType SqueezerXalignPropertyInfo = Float
    type AttrGetType SqueezerXalignPropertyInfo = Float
    type AttrLabel SqueezerXalignPropertyInfo = "xalign"
    type AttrOrigin SqueezerXalignPropertyInfo = Squeezer
    attrGet = getSqueezerXalign
    attrSet = setSqueezerXalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerXalign
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Squeezer.xalign"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-Squeezer.html#g:attr:xalign"
        })
#endif

-- VVV Prop "yalign"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

-- | Set the value of the “@yalign@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' squeezer [ #yalign 'Data.GI.Base.Attributes.:=' value ]
-- @
setSqueezerYalign :: (MonadIO m, IsSqueezer o) => o -> Float -> m ()
setSqueezerYalign :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezer o) =>
o -> Float -> m ()
setSqueezerYalign o
obj Float
val = IO () -> m ()
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 -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"yalign" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@yalign@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSqueezerYalign :: (IsSqueezer o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructSqueezerYalign :: forall o (m :: * -> *).
(IsSqueezer o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructSqueezerYalign Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"yalign" Float
val

#if defined(ENABLE_OVERLOADING)
data SqueezerYalignPropertyInfo
instance AttrInfo SqueezerYalignPropertyInfo where
    type AttrAllowedOps SqueezerYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerYalignPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerYalignPropertyInfo = (~) Float
    type AttrTransferTypeConstraint SqueezerYalignPropertyInfo = (~) Float
    type AttrTransferType SqueezerYalignPropertyInfo = Float
    type AttrGetType SqueezerYalignPropertyInfo = Float
    type AttrLabel SqueezerYalignPropertyInfo = "yalign"
    type AttrOrigin SqueezerYalignPropertyInfo = Squeezer
    attrGet = getSqueezerYalign
    attrSet = setSqueezerYalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerYalign
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Squeezer.yalign"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-Squeezer.html#g:attr:yalign"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Squeezer
type instance O.AttributeList Squeezer = SqueezerAttributeList
type SqueezerAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("allowNone", SqueezerAllowNonePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("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), '("homogeneous", SqueezerHomogeneousPropertyInfo), '("interpolateSize", SqueezerInterpolateSizePropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("orientation", Gtk.Orientable.OrientableOrientationPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("pages", SqueezerPagesPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("switchThresholdPolicy", SqueezerSwitchThresholdPolicyPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("transitionDuration", SqueezerTransitionDurationPropertyInfo), '("transitionRunning", SqueezerTransitionRunningPropertyInfo), '("transitionType", SqueezerTransitionTypePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("visibleChild", SqueezerVisibleChildPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("xalign", SqueezerXalignPropertyInfo), '("yalign", SqueezerYalignPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
squeezerAllowNone :: AttrLabelProxy "allowNone"
squeezerAllowNone = AttrLabelProxy

squeezerHomogeneous :: AttrLabelProxy "homogeneous"
squeezerHomogeneous = AttrLabelProxy

squeezerInterpolateSize :: AttrLabelProxy "interpolateSize"
squeezerInterpolateSize = AttrLabelProxy

squeezerPages :: AttrLabelProxy "pages"
squeezerPages = AttrLabelProxy

squeezerSwitchThresholdPolicy :: AttrLabelProxy "switchThresholdPolicy"
squeezerSwitchThresholdPolicy = AttrLabelProxy

squeezerTransitionDuration :: AttrLabelProxy "transitionDuration"
squeezerTransitionDuration = AttrLabelProxy

squeezerTransitionRunning :: AttrLabelProxy "transitionRunning"
squeezerTransitionRunning = AttrLabelProxy

squeezerTransitionType :: AttrLabelProxy "transitionType"
squeezerTransitionType = AttrLabelProxy

squeezerVisibleChild :: AttrLabelProxy "visibleChild"
squeezerVisibleChild = AttrLabelProxy

squeezerXalign :: AttrLabelProxy "xalign"
squeezerXalign = AttrLabelProxy

squeezerYalign :: AttrLabelProxy "yalign"
squeezerYalign = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Squeezer = SqueezerSignalList
type SqueezerSignalList = ('[ '("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, *)])

#endif

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

foreign import ccall "adw_squeezer_new" adw_squeezer_new :: 
    IO (Ptr Squeezer)

-- | Creates a new @AdwSqueezer@.
-- 
-- /Since: 1.0/
squeezerNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Squeezer
    -- ^ __Returns:__ the newly created @AdwSqueezer@
squeezerNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Squeezer
squeezerNew  = IO Squeezer -> m Squeezer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Squeezer -> m Squeezer) -> IO Squeezer -> m Squeezer
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
result <- IO (Ptr Squeezer)
adw_squeezer_new
    Text -> Ptr Squeezer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"squeezerNew" Ptr Squeezer
result
    Squeezer
result' <- ((ManagedPtr Squeezer -> Squeezer) -> Ptr Squeezer -> IO Squeezer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Squeezer -> Squeezer
Squeezer) Ptr Squeezer
result
    Squeezer -> IO Squeezer
forall (m :: * -> *) a. Monad m => a -> m a
return Squeezer
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Squeezer::add
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , 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 to add" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Adw" , name = "SqueezerPage" })
-- throws : False
-- Skip return : False

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

-- | Adds a child to /@self@/.
-- 
-- /Since: 1.0/
squeezerAdd ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> b
    -- ^ /@child@/: the widget to add
    -> m Adw.SqueezerPage.SqueezerPage
    -- ^ __Returns:__ the t'GI.Adw.Objects.SqueezerPage.SqueezerPage' for /@child@/
squeezerAdd :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSqueezer a, IsWidget b) =>
a -> b -> m SqueezerPage
squeezerAdd a
self b
child = IO SqueezerPage -> m SqueezerPage
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SqueezerPage -> m SqueezerPage)
-> IO SqueezerPage -> m SqueezerPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr SqueezerPage
result <- Ptr Squeezer -> Ptr Widget -> IO (Ptr SqueezerPage)
adw_squeezer_add Ptr Squeezer
self' Ptr Widget
child'
    Text -> Ptr SqueezerPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"squeezerAdd" Ptr SqueezerPage
result
    SqueezerPage
result' <- ((ManagedPtr SqueezerPage -> SqueezerPage)
-> Ptr SqueezerPage -> IO SqueezerPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SqueezerPage -> SqueezerPage
Adw.SqueezerPage.SqueezerPage) Ptr SqueezerPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    SqueezerPage -> IO SqueezerPage
forall (m :: * -> *) a. Monad m => a -> m a
return SqueezerPage
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerAddMethodInfo
instance (signature ~ (b -> m Adw.SqueezerPage.SqueezerPage), MonadIO m, IsSqueezer a, Gtk.Widget.IsWidget b) => O.OverloadedMethod SqueezerAddMethodInfo a signature where
    overloadedMethod = squeezerAdd

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


#endif

-- method Squeezer::get_allow_none
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , 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 "adw_squeezer_get_allow_none" adw_squeezer_get_allow_none :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    IO CInt

-- | Gets whether to allow squeezing beyond the last child\'s minimum size.
-- 
-- /Since: 1.0/
squeezerGetAllowNone ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ allows squeezing beyond the last child
squeezerGetAllowNone :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Bool
squeezerGetAllowNone a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Squeezer -> IO CInt
adw_squeezer_get_allow_none Ptr Squeezer
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetAllowNoneMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetAllowNoneMethodInfo a signature where
    overloadedMethod = squeezerGetAllowNone

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


#endif

-- method Squeezer::get_homogeneous
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , 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 "adw_squeezer_get_homogeneous" adw_squeezer_get_homogeneous :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    IO CInt

-- | Gets whether all children have the same size for the opposite orientation.
-- 
-- /Since: 1.0/
squeezerGetHomogeneous ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ is homogeneous
squeezerGetHomogeneous :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Bool
squeezerGetHomogeneous a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Squeezer -> IO CInt
adw_squeezer_get_homogeneous Ptr Squeezer
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetHomogeneousMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetHomogeneousMethodInfo a signature where
    overloadedMethod = squeezerGetHomogeneous

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


#endif

-- method Squeezer::get_interpolate_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A `AdwSqueezer`" , 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 "adw_squeezer_get_interpolate_size" adw_squeezer_get_interpolate_size :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    IO CInt

-- | Gets whether /@self@/ interpolates its size when changing the visible child.
-- 
-- /Since: 1.0/
squeezerGetInterpolateSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: A @AdwSqueezer@
    -> m Bool
    -- ^ __Returns:__ whether the size is interpolated
squeezerGetInterpolateSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Bool
squeezerGetInterpolateSize a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Squeezer -> IO CInt
adw_squeezer_get_interpolate_size Ptr Squeezer
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetInterpolateSizeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetInterpolateSizeMethodInfo a signature where
    overloadedMethod = squeezerGetInterpolateSize

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


#endif

-- method Squeezer::get_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , 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 "a child of @self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Adw" , name = "SqueezerPage" })
-- throws : False
-- Skip return : False

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

-- | Returns the t'GI.Adw.Objects.SqueezerPage.SqueezerPage' object for /@child@/.
-- 
-- /Since: 1.0/
squeezerGetPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> b
    -- ^ /@child@/: a child of /@self@/
    -> m Adw.SqueezerPage.SqueezerPage
    -- ^ __Returns:__ the page object for /@child@/
squeezerGetPage :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSqueezer a, IsWidget b) =>
a -> b -> m SqueezerPage
squeezerGetPage a
self b
child = IO SqueezerPage -> m SqueezerPage
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SqueezerPage -> m SqueezerPage)
-> IO SqueezerPage -> m SqueezerPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr SqueezerPage
result <- Ptr Squeezer -> Ptr Widget -> IO (Ptr SqueezerPage)
adw_squeezer_get_page Ptr Squeezer
self' Ptr Widget
child'
    Text -> Ptr SqueezerPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"squeezerGetPage" Ptr SqueezerPage
result
    SqueezerPage
result' <- ((ManagedPtr SqueezerPage -> SqueezerPage)
-> Ptr SqueezerPage -> IO SqueezerPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SqueezerPage -> SqueezerPage
Adw.SqueezerPage.SqueezerPage) Ptr SqueezerPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    SqueezerPage -> IO SqueezerPage
forall (m :: * -> *) a. Monad m => a -> m a
return SqueezerPage
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetPageMethodInfo
instance (signature ~ (b -> m Adw.SqueezerPage.SqueezerPage), MonadIO m, IsSqueezer a, Gtk.Widget.IsWidget b) => O.OverloadedMethod SqueezerGetPageMethodInfo a signature where
    overloadedMethod = squeezerGetPage

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


#endif

-- method Squeezer::get_pages
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "SelectionModel" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_get_pages" adw_squeezer_get_pages :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    IO (Ptr Gtk.SelectionModel.SelectionModel)

-- | Returns a t'GI.Gio.Interfaces.ListModel.ListModel' that contains the pages of /@self@/.
-- 
-- This can be used to keep an up-to-date view. The model also implements
-- t'GI.Gtk.Interfaces.SelectionModel.SelectionModel' and can be used to track the visible page.
-- 
-- /Since: 1.0/
squeezerGetPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> m Gtk.SelectionModel.SelectionModel
    -- ^ __Returns:__ a @GtkSelectionModel@ for the squeezer\'s children
squeezerGetPages :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m SelectionModel
squeezerGetPages a
self = IO SelectionModel -> m SelectionModel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SelectionModel -> m SelectionModel)
-> IO SelectionModel -> m SelectionModel
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SelectionModel
result <- Ptr Squeezer -> IO (Ptr SelectionModel)
adw_squeezer_get_pages Ptr Squeezer
self'
    Text -> Ptr SelectionModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"squeezerGetPages" Ptr SelectionModel
result
    SelectionModel
result' <- ((ManagedPtr SelectionModel -> SelectionModel)
-> Ptr SelectionModel -> IO SelectionModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SelectionModel -> SelectionModel
Gtk.SelectionModel.SelectionModel) Ptr SelectionModel
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    SelectionModel -> IO SelectionModel
forall (m :: * -> *) a. Monad m => a -> m a
return SelectionModel
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetPagesMethodInfo
instance (signature ~ (m Gtk.SelectionModel.SelectionModel), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetPagesMethodInfo a signature where
    overloadedMethod = squeezerGetPages

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


#endif

-- method Squeezer::get_switch_threshold_policy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwLeaflet`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Adw" , name = "FoldThresholdPolicy" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_get_switch_threshold_policy" adw_squeezer_get_switch_threshold_policy :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    IO CUInt

-- | Gets the fold threshold policy for /@self@/.
-- 
-- /Since: 1.0/
squeezerGetSwitchThresholdPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwLeaflet@
    -> m Adw.Enums.FoldThresholdPolicy
squeezerGetSwitchThresholdPolicy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m FoldThresholdPolicy
squeezerGetSwitchThresholdPolicy a
self = IO FoldThresholdPolicy -> m FoldThresholdPolicy
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FoldThresholdPolicy -> m FoldThresholdPolicy)
-> IO FoldThresholdPolicy -> m FoldThresholdPolicy
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Squeezer -> IO CUInt
adw_squeezer_get_switch_threshold_policy Ptr Squeezer
self'
    let result' :: FoldThresholdPolicy
result' = (Int -> FoldThresholdPolicy
forall a. Enum a => Int -> a
toEnum (Int -> FoldThresholdPolicy)
-> (CUInt -> Int) -> CUInt -> FoldThresholdPolicy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    FoldThresholdPolicy -> IO FoldThresholdPolicy
forall (m :: * -> *) a. Monad m => a -> m a
return FoldThresholdPolicy
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetSwitchThresholdPolicyMethodInfo
instance (signature ~ (m Adw.Enums.FoldThresholdPolicy), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetSwitchThresholdPolicyMethodInfo a signature where
    overloadedMethod = squeezerGetSwitchThresholdPolicy

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


#endif

-- method Squeezer::get_transition_duration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_get_transition_duration" adw_squeezer_get_transition_duration :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    IO Word32

-- | Gets the transition animation duration for /@self@/.
-- 
-- /Since: 1.0/
squeezerGetTransitionDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> m Word32
    -- ^ __Returns:__ the transition duration, in milliseconds
squeezerGetTransitionDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Word32
squeezerGetTransitionDuration a
self = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Squeezer -> IO Word32
adw_squeezer_get_transition_duration Ptr Squeezer
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data SqueezerGetTransitionDurationMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetTransitionDurationMethodInfo a signature where
    overloadedMethod = squeezerGetTransitionDuration

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


#endif

-- method Squeezer::get_transition_running
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , 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 "adw_squeezer_get_transition_running" adw_squeezer_get_transition_running :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    IO CInt

-- | Gets whether a transition is currently running for /@self@/.
-- 
-- /Since: 1.0/
squeezerGetTransitionRunning ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> m Bool
    -- ^ __Returns:__ whether a transition is currently running
squeezerGetTransitionRunning :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Bool
squeezerGetTransitionRunning a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Squeezer -> IO CInt
adw_squeezer_get_transition_running Ptr Squeezer
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetTransitionRunningMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetTransitionRunningMethodInfo a signature where
    overloadedMethod = squeezerGetTransitionRunning

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


#endif

-- method Squeezer::get_transition_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Adw" , name = "SqueezerTransitionType" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_get_transition_type" adw_squeezer_get_transition_type :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    IO CUInt

-- | Gets the type of animation used for transitions between children in /@self@/.
-- 
-- /Since: 1.0/
squeezerGetTransitionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> m Adw.Enums.SqueezerTransitionType
    -- ^ __Returns:__ the current transition type of /@self@/
squeezerGetTransitionType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m SqueezerTransitionType
squeezerGetTransitionType a
self = IO SqueezerTransitionType -> m SqueezerTransitionType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SqueezerTransitionType -> m SqueezerTransitionType)
-> IO SqueezerTransitionType -> m SqueezerTransitionType
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Squeezer -> IO CUInt
adw_squeezer_get_transition_type Ptr Squeezer
self'
    let result' :: SqueezerTransitionType
result' = (Int -> SqueezerTransitionType
forall a. Enum a => Int -> a
toEnum (Int -> SqueezerTransitionType)
-> (CUInt -> Int) -> CUInt -> SqueezerTransitionType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    SqueezerTransitionType -> IO SqueezerTransitionType
forall (m :: * -> *) a. Monad m => a -> m a
return SqueezerTransitionType
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetTransitionTypeMethodInfo
instance (signature ~ (m Adw.Enums.SqueezerTransitionType), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetTransitionTypeMethodInfo a signature where
    overloadedMethod = squeezerGetTransitionType

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


#endif

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

-- | Gets the currently visible child of /@self@/.
-- 
-- /Since: 1.0/
squeezerGetVisibleChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the visible child
squeezerGetVisibleChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m (Maybe Widget)
squeezerGetVisibleChild a
self = IO (Maybe Widget) -> m (Maybe Widget)
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 Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr Squeezer -> IO (Ptr Widget)
adw_squeezer_get_visible_child Ptr Squeezer
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 (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 (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

-- method Squeezer::get_xalign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_get_xalign" adw_squeezer_get_xalign :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    IO CFloat

-- | Gets the horizontal alignment, from 0 (start) to 1 (end).
-- 
-- /Since: 1.0/
squeezerGetXalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> m Float
    -- ^ __Returns:__ the alignment value
squeezerGetXalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Float
squeezerGetXalign a
self = IO Float -> m Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Squeezer -> IO CFloat
adw_squeezer_get_xalign Ptr Squeezer
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetXalignMethodInfo
instance (signature ~ (m Float), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetXalignMethodInfo a signature where
    overloadedMethod = squeezerGetXalign

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


#endif

-- method Squeezer::get_yalign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_get_yalign" adw_squeezer_get_yalign :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    IO CFloat

-- | Gets the vertical alignment, from 0 (top) to 1 (bottom).
-- 
-- /Since: 1.0/
squeezerGetYalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> m Float
    -- ^ __Returns:__ the alignment value
squeezerGetYalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Float
squeezerGetYalign a
self = IO Float -> m Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Squeezer -> IO CFloat
adw_squeezer_get_yalign Ptr Squeezer
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetYalignMethodInfo
instance (signature ~ (m Float), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetYalignMethodInfo a signature where
    overloadedMethod = squeezerGetYalign

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


#endif

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

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

-- | Removes a child widget from /@self@/.
-- 
-- /Since: 1.0/
squeezerRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> b
    -- ^ /@child@/: the child to remove
    -> m ()
squeezerRemove :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSqueezer a, IsWidget b) =>
a -> b -> m ()
squeezerRemove a
self b
child = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Squeezer -> Ptr Widget -> IO ()
adw_squeezer_remove Ptr Squeezer
self' Ptr Widget
child'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerRemoveMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsSqueezer a, Gtk.Widget.IsWidget b) => O.OverloadedMethod SqueezerRemoveMethodInfo a signature where
    overloadedMethod = squeezerRemove

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


#endif

-- method Squeezer::set_allow_none
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_none"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether @self allows squeezing beyond the last child"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_set_allow_none" adw_squeezer_set_allow_none :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    CInt ->                                 -- allow_none : TBasicType TBoolean
    IO ()

-- | Sets whether to allow squeezing beyond the last child\'s minimum size.
-- 
-- /Since: 1.0/
squeezerSetAllowNone ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> Bool
    -- ^ /@allowNone@/: whether /@self@/ allows squeezing beyond the last child
    -> m ()
squeezerSetAllowNone :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> Bool -> m ()
squeezerSetAllowNone a
self Bool
allowNone = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let allowNone' :: CInt
allowNone' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
allowNone
    Ptr Squeezer -> CInt -> IO ()
adw_squeezer_set_allow_none Ptr Squeezer
self' CInt
allowNone'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetAllowNoneMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetAllowNoneMethodInfo a signature where
    overloadedMethod = squeezerSetAllowNone

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


#endif

-- method Squeezer::set_homogeneous
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "homogeneous"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether @self is homogeneous"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_set_homogeneous" adw_squeezer_set_homogeneous :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    CInt ->                                 -- homogeneous : TBasicType TBoolean
    IO ()

-- | Sets whether all children have the same size for the opposite orientation.
-- 
-- /Since: 1.0/
squeezerSetHomogeneous ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> Bool
    -- ^ /@homogeneous@/: whether /@self@/ is homogeneous
    -> m ()
squeezerSetHomogeneous :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> Bool -> m ()
squeezerSetHomogeneous a
self Bool
homogeneous = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let homogeneous' :: CInt
homogeneous' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
homogeneous
    Ptr Squeezer -> CInt -> IO ()
adw_squeezer_set_homogeneous Ptr Squeezer
self' CInt
homogeneous'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetHomogeneousMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetHomogeneousMethodInfo a signature where
    overloadedMethod = squeezerSetHomogeneous

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


#endif

-- method Squeezer::set_interpolate_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interpolate_size"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to interpolate the 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_squeezer_set_interpolate_size" adw_squeezer_set_interpolate_size :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    CInt ->                                 -- interpolate_size : TBasicType TBoolean
    IO ()

-- | Sets whether /@self@/ interpolates its size when changing the visible child.
-- 
-- /Since: 1.0/
squeezerSetInterpolateSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: A @AdwSqueezer@
    -> Bool
    -- ^ /@interpolateSize@/: whether to interpolate the size
    -> m ()
squeezerSetInterpolateSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> Bool -> m ()
squeezerSetInterpolateSize a
self Bool
interpolateSize = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let interpolateSize' :: CInt
interpolateSize' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
interpolateSize
    Ptr Squeezer -> CInt -> IO ()
adw_squeezer_set_interpolate_size Ptr Squeezer
self' CInt
interpolateSize'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetInterpolateSizeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetInterpolateSizeMethodInfo a signature where
    overloadedMethod = squeezerSetInterpolateSize

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


#endif

-- method Squeezer::set_switch_threshold_policy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "policy"
--           , argType =
--               TInterface
--                 Name { namespace = "Adw" , name = "FoldThresholdPolicy" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the policy to use" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_set_switch_threshold_policy" adw_squeezer_set_switch_threshold_policy :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    CUInt ->                                -- policy : TInterface (Name {namespace = "Adw", name = "FoldThresholdPolicy"})
    IO ()

-- | Sets the fold threshold policy for /@self@/.
-- 
-- /Since: 1.0/
squeezerSetSwitchThresholdPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> Adw.Enums.FoldThresholdPolicy
    -- ^ /@policy@/: the policy to use
    -> m ()
squeezerSetSwitchThresholdPolicy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> FoldThresholdPolicy -> m ()
squeezerSetSwitchThresholdPolicy a
self FoldThresholdPolicy
policy = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let policy' :: CUInt
policy' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (FoldThresholdPolicy -> Int) -> FoldThresholdPolicy -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FoldThresholdPolicy -> Int
forall a. Enum a => a -> Int
fromEnum) FoldThresholdPolicy
policy
    Ptr Squeezer -> CUInt -> IO ()
adw_squeezer_set_switch_threshold_policy Ptr Squeezer
self' CUInt
policy'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetSwitchThresholdPolicyMethodInfo
instance (signature ~ (Adw.Enums.FoldThresholdPolicy -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetSwitchThresholdPolicyMethodInfo a signature where
    overloadedMethod = squeezerSetSwitchThresholdPolicy

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


#endif

-- method Squeezer::set_transition_duration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "duration"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new duration, in milliseconds"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_set_transition_duration" adw_squeezer_set_transition_duration :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    Word32 ->                               -- duration : TBasicType TUInt
    IO ()

-- | Sets the transition animation duration for /@self@/.
-- 
-- /Since: 1.0/
squeezerSetTransitionDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> Word32
    -- ^ /@duration@/: the new duration, in milliseconds
    -> m ()
squeezerSetTransitionDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> Word32 -> m ()
squeezerSetTransitionDuration a
self Word32
duration = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Squeezer -> Word32 -> IO ()
adw_squeezer_set_transition_duration Ptr Squeezer
self' Word32
duration
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetTransitionDurationMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetTransitionDurationMethodInfo a signature where
    overloadedMethod = squeezerSetTransitionDuration

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


#endif

-- method Squeezer::set_transition_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "transition"
--           , argType =
--               TInterface
--                 Name { namespace = "Adw" , name = "SqueezerTransitionType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new transition type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_set_transition_type" adw_squeezer_set_transition_type :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    CUInt ->                                -- transition : TInterface (Name {namespace = "Adw", name = "SqueezerTransitionType"})
    IO ()

-- | Sets the type of animation used for transitions between children in /@self@/.
-- 
-- /Since: 1.0/
squeezerSetTransitionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> Adw.Enums.SqueezerTransitionType
    -- ^ /@transition@/: the new transition type
    -> m ()
squeezerSetTransitionType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> SqueezerTransitionType -> m ()
squeezerSetTransitionType a
self SqueezerTransitionType
transition = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let transition' :: CUInt
transition' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (SqueezerTransitionType -> Int)
-> SqueezerTransitionType
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqueezerTransitionType -> Int
forall a. Enum a => a -> Int
fromEnum) SqueezerTransitionType
transition
    Ptr Squeezer -> CUInt -> IO ()
adw_squeezer_set_transition_type Ptr Squeezer
self' CUInt
transition'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetTransitionTypeMethodInfo
instance (signature ~ (Adw.Enums.SqueezerTransitionType -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetTransitionTypeMethodInfo a signature where
    overloadedMethod = squeezerSetTransitionType

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


#endif

-- method Squeezer::set_xalign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xalign"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new alignment value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_set_xalign" adw_squeezer_set_xalign :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    CFloat ->                               -- xalign : TBasicType TFloat
    IO ()

-- | Sets the horizontal alignment, from 0 (start) to 1 (end).
-- 
-- /Since: 1.0/
squeezerSetXalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> Float
    -- ^ /@xalign@/: the new alignment value
    -> m ()
squeezerSetXalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> Float -> m ()
squeezerSetXalign a
self Float
xalign = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let xalign' :: CFloat
xalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
xalign
    Ptr Squeezer -> CFloat -> IO ()
adw_squeezer_set_xalign Ptr Squeezer
self' CFloat
xalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetXalignMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetXalignMethodInfo a signature where
    overloadedMethod = squeezerSetXalign

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


#endif

-- method Squeezer::set_yalign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSqueezer`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "yalign"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new alignment value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_squeezer_set_yalign" adw_squeezer_set_yalign :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Adw", name = "Squeezer"})
    CFloat ->                               -- yalign : TBasicType TFloat
    IO ()

-- | Sets the vertical alignment, from 0 (top) to 1 (bottom).
-- 
-- /Since: 1.0/
squeezerSetYalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a @AdwSqueezer@
    -> Float
    -- ^ /@yalign@/: the new alignment value
    -> m ()
squeezerSetYalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> Float -> m ()
squeezerSetYalign a
self Float
yalign = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let yalign' :: CFloat
yalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
yalign
    Ptr Squeezer -> CFloat -> IO ()
adw_squeezer_set_yalign Ptr Squeezer
self' CFloat
yalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetYalignMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetYalignMethodInfo a signature where
    overloadedMethod = squeezerSetYalign

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


#endif