{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An adaptive container acting like a box or a stack.
-- 
-- \<picture>
--   \<source srcset=\"leaflet-wide-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"leaflet-wide.png\" alt=\"leaflet-wide\">
-- \<\/picture>
-- \<picture>
--   \<source srcset=\"leaflet-narrow-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"leaflet-narrow.png\" alt=\"leaflet-narrow\">
-- \<\/picture>
-- 
-- The @AdwLeaflet@ widget can display its children like a t'GI.Gtk.Objects.Box.Box' does
-- or like a t'GI.Gtk.Objects.Stack.Stack' does, adapting to size changes by switching
-- between the two modes.
-- 
-- When there is enough space the children are displayed side by side, otherwise
-- only one is displayed and the leaflet is said to be “folded”.
-- The threshold is dictated by the preferred minimum sizes of the children.
-- When a leaflet is folded, the children can be navigated using swipe gestures.
-- 
-- The “over” and “under” transition types stack the children one on top of the
-- other, while the “slide” transition puts the children side by side. While
-- navigating to a child on the side or below can be performed by swiping the
-- current child away, navigating to an upper child requires dragging it from
-- the edge where it resides. This doesn\'t affect non-dragging swipes.
-- 
-- == CSS nodes
-- 
-- @AdwLeaflet@ has a single CSS node with name @leaflet@. The node will get the
-- style classes @.folded@ when it is folded, @.unfolded@ when it\'s not, or none
-- if it hasn\'t computed its fold yet.

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

module GI.Adw.Objects.Leaflet
    ( 

-- * Exported types
    Leaflet(..)                             ,
    IsLeaflet                               ,
    toLeaflet                               ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [append]("GI.Adw.Objects.Leaflet#g:method:append"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [insertChildAfter]("GI.Adw.Objects.Leaflet#g:method:insertChildAfter"), [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"), [navigate]("GI.Adw.Objects.Leaflet#g:method:navigate"), [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"), [prepend]("GI.Adw.Objects.Leaflet#g:method:prepend"), [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.Leaflet#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"), [reorderChildAfter]("GI.Adw.Objects.Leaflet#g:method:reorderChildAfter"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAdjacentChild]("GI.Adw.Objects.Leaflet#g:method:getAdjacentChild"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanNavigateBack]("GI.Adw.Objects.Leaflet#g:method:getCanNavigateBack"), [getCanNavigateForward]("GI.Adw.Objects.Leaflet#g:method:getCanNavigateForward"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getCanUnfold]("GI.Adw.Objects.Leaflet#g:method:getCanUnfold"), [getCancelProgress]("GI.Adw.Interfaces.Swipeable#g:method:getCancelProgress"), [getChildByName]("GI.Adw.Objects.Leaflet#g:method:getChildByName"), [getChildTransitionParams]("GI.Adw.Objects.Leaflet#g:method:getChildTransitionParams"), [getChildTransitionRunning]("GI.Adw.Objects.Leaflet#g:method:getChildTransitionRunning"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getDistance]("GI.Adw.Interfaces.Swipeable#g:method:getDistance"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFoldThresholdPolicy]("GI.Adw.Objects.Leaflet#g:method:getFoldThresholdPolicy"), [getFolded]("GI.Adw.Objects.Leaflet#g:method:getFolded"), [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.Leaflet#g:method:getHomogeneous"), [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"), [getModeTransitionDuration]("GI.Adw.Objects.Leaflet#g:method:getModeTransitionDuration"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOrientation]("GI.Gtk.Interfaces.Orientable#g:method:getOrientation"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPage]("GI.Adw.Objects.Leaflet#g:method:getPage"), [getPages]("GI.Adw.Objects.Leaflet#g:method:getPages"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProgress]("GI.Adw.Interfaces.Swipeable#g:method:getProgress"), [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"), [getSnapPoints]("GI.Adw.Interfaces.Swipeable#g:method:getSnapPoints"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSwipeArea]("GI.Adw.Interfaces.Swipeable#g:method:getSwipeArea"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTransitionType]("GI.Adw.Objects.Leaflet#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.Leaflet#g:method:getVisibleChild"), [getVisibleChildName]("GI.Adw.Objects.Leaflet#g:method:getVisibleChildName"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
-- 
-- ==== Setters
-- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanNavigateBack]("GI.Adw.Objects.Leaflet#g:method:setCanNavigateBack"), [setCanNavigateForward]("GI.Adw.Objects.Leaflet#g:method:setCanNavigateForward"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setCanUnfold]("GI.Adw.Objects.Leaflet#g:method:setCanUnfold"), [setChildTransitionParams]("GI.Adw.Objects.Leaflet#g:method:setChildTransitionParams"), [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"), [setFoldThresholdPolicy]("GI.Adw.Objects.Leaflet#g:method:setFoldThresholdPolicy"), [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.Leaflet#g:method:setHomogeneous"), [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"), [setModeTransitionDuration]("GI.Adw.Objects.Leaflet#g:method:setModeTransitionDuration"), [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"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTransitionType]("GI.Adw.Objects.Leaflet#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"), [setVisibleChild]("GI.Adw.Objects.Leaflet#g:method:setVisibleChild"), [setVisibleChildName]("GI.Adw.Objects.Leaflet#g:method:setVisibleChildName").

#if defined(ENABLE_OVERLOADING)
    ResolveLeafletMethod                    ,
#endif

-- ** append #method:append#

#if defined(ENABLE_OVERLOADING)
    LeafletAppendMethodInfo                 ,
#endif
    leafletAppend                           ,


-- ** getAdjacentChild #method:getAdjacentChild#

#if defined(ENABLE_OVERLOADING)
    LeafletGetAdjacentChildMethodInfo       ,
#endif
    leafletGetAdjacentChild                 ,


-- ** getCanNavigateBack #method:getCanNavigateBack#

#if defined(ENABLE_OVERLOADING)
    LeafletGetCanNavigateBackMethodInfo     ,
#endif
    leafletGetCanNavigateBack               ,


-- ** getCanNavigateForward #method:getCanNavigateForward#

#if defined(ENABLE_OVERLOADING)
    LeafletGetCanNavigateForwardMethodInfo  ,
#endif
    leafletGetCanNavigateForward            ,


-- ** getCanUnfold #method:getCanUnfold#

#if defined(ENABLE_OVERLOADING)
    LeafletGetCanUnfoldMethodInfo           ,
#endif
    leafletGetCanUnfold                     ,


-- ** getChildByName #method:getChildByName#

#if defined(ENABLE_OVERLOADING)
    LeafletGetChildByNameMethodInfo         ,
#endif
    leafletGetChildByName                   ,


-- ** getChildTransitionParams #method:getChildTransitionParams#

#if defined(ENABLE_OVERLOADING)
    LeafletGetChildTransitionParamsMethodInfo,
#endif
    leafletGetChildTransitionParams         ,


-- ** getChildTransitionRunning #method:getChildTransitionRunning#

#if defined(ENABLE_OVERLOADING)
    LeafletGetChildTransitionRunningMethodInfo,
#endif
    leafletGetChildTransitionRunning        ,


-- ** getFoldThresholdPolicy #method:getFoldThresholdPolicy#

#if defined(ENABLE_OVERLOADING)
    LeafletGetFoldThresholdPolicyMethodInfo ,
#endif
    leafletGetFoldThresholdPolicy           ,


-- ** getFolded #method:getFolded#

#if defined(ENABLE_OVERLOADING)
    LeafletGetFoldedMethodInfo              ,
#endif
    leafletGetFolded                        ,


-- ** getHomogeneous #method:getHomogeneous#

#if defined(ENABLE_OVERLOADING)
    LeafletGetHomogeneousMethodInfo         ,
#endif
    leafletGetHomogeneous                   ,


-- ** getModeTransitionDuration #method:getModeTransitionDuration#

#if defined(ENABLE_OVERLOADING)
    LeafletGetModeTransitionDurationMethodInfo,
#endif
    leafletGetModeTransitionDuration        ,


-- ** getPage #method:getPage#

#if defined(ENABLE_OVERLOADING)
    LeafletGetPageMethodInfo                ,
#endif
    leafletGetPage                          ,


-- ** getPages #method:getPages#

#if defined(ENABLE_OVERLOADING)
    LeafletGetPagesMethodInfo               ,
#endif
    leafletGetPages                         ,


-- ** getTransitionType #method:getTransitionType#

#if defined(ENABLE_OVERLOADING)
    LeafletGetTransitionTypeMethodInfo      ,
#endif
    leafletGetTransitionType                ,


-- ** getVisibleChild #method:getVisibleChild#

#if defined(ENABLE_OVERLOADING)
    LeafletGetVisibleChildMethodInfo        ,
#endif
    leafletGetVisibleChild                  ,


-- ** getVisibleChildName #method:getVisibleChildName#

#if defined(ENABLE_OVERLOADING)
    LeafletGetVisibleChildNameMethodInfo    ,
#endif
    leafletGetVisibleChildName              ,


-- ** insertChildAfter #method:insertChildAfter#

#if defined(ENABLE_OVERLOADING)
    LeafletInsertChildAfterMethodInfo       ,
#endif
    leafletInsertChildAfter                 ,


-- ** navigate #method:navigate#

#if defined(ENABLE_OVERLOADING)
    LeafletNavigateMethodInfo               ,
#endif
    leafletNavigate                         ,


-- ** new #method:new#

    leafletNew                              ,


-- ** prepend #method:prepend#

#if defined(ENABLE_OVERLOADING)
    LeafletPrependMethodInfo                ,
#endif
    leafletPrepend                          ,


-- ** remove #method:remove#

#if defined(ENABLE_OVERLOADING)
    LeafletRemoveMethodInfo                 ,
#endif
    leafletRemove                           ,


-- ** reorderChildAfter #method:reorderChildAfter#

#if defined(ENABLE_OVERLOADING)
    LeafletReorderChildAfterMethodInfo      ,
#endif
    leafletReorderChildAfter                ,


-- ** setCanNavigateBack #method:setCanNavigateBack#

#if defined(ENABLE_OVERLOADING)
    LeafletSetCanNavigateBackMethodInfo     ,
#endif
    leafletSetCanNavigateBack               ,


-- ** setCanNavigateForward #method:setCanNavigateForward#

#if defined(ENABLE_OVERLOADING)
    LeafletSetCanNavigateForwardMethodInfo  ,
#endif
    leafletSetCanNavigateForward            ,


-- ** setCanUnfold #method:setCanUnfold#

#if defined(ENABLE_OVERLOADING)
    LeafletSetCanUnfoldMethodInfo           ,
#endif
    leafletSetCanUnfold                     ,


-- ** setChildTransitionParams #method:setChildTransitionParams#

#if defined(ENABLE_OVERLOADING)
    LeafletSetChildTransitionParamsMethodInfo,
#endif
    leafletSetChildTransitionParams         ,


-- ** setFoldThresholdPolicy #method:setFoldThresholdPolicy#

#if defined(ENABLE_OVERLOADING)
    LeafletSetFoldThresholdPolicyMethodInfo ,
#endif
    leafletSetFoldThresholdPolicy           ,


-- ** setHomogeneous #method:setHomogeneous#

#if defined(ENABLE_OVERLOADING)
    LeafletSetHomogeneousMethodInfo         ,
#endif
    leafletSetHomogeneous                   ,


-- ** setModeTransitionDuration #method:setModeTransitionDuration#

#if defined(ENABLE_OVERLOADING)
    LeafletSetModeTransitionDurationMethodInfo,
#endif
    leafletSetModeTransitionDuration        ,


-- ** setTransitionType #method:setTransitionType#

#if defined(ENABLE_OVERLOADING)
    LeafletSetTransitionTypeMethodInfo      ,
#endif
    leafletSetTransitionType                ,


-- ** setVisibleChild #method:setVisibleChild#

#if defined(ENABLE_OVERLOADING)
    LeafletSetVisibleChildMethodInfo        ,
#endif
    leafletSetVisibleChild                  ,


-- ** setVisibleChildName #method:setVisibleChildName#

#if defined(ENABLE_OVERLOADING)
    LeafletSetVisibleChildNameMethodInfo    ,
#endif
    leafletSetVisibleChildName              ,




 -- * Properties


-- ** canNavigateBack #attr:canNavigateBack#
-- | Whether gestures and shortcuts for navigating backward are enabled.
-- 
-- The supported gestures are:
-- 
-- * One-finger swipe on touchscreens
-- * Horizontal scrolling on touchpads (usually two-finger swipe)
-- * Back\/forward mouse buttons
-- 
-- 
-- The keyboard back\/forward keys are also supported, as well as the
-- \<kbd>Alt\<\/kbd>+\<kbd>←\<\/kbd> shortcut for horizontal orientation, or
-- \<kbd>Alt\<\/kbd>+\<kbd>↑\<\/kbd> for vertical orientation.
-- 
-- If the orientation is horizontal, for right-to-left locales, gestures and
-- shortcuts are reversed.
-- 
-- Only children that have [property/@leafletPage@/:navigatable] set to @TRUE@
-- can be navigated to.

#if defined(ENABLE_OVERLOADING)
    LeafletCanNavigateBackPropertyInfo      ,
#endif
    constructLeafletCanNavigateBack         ,
    getLeafletCanNavigateBack               ,
#if defined(ENABLE_OVERLOADING)
    leafletCanNavigateBack                  ,
#endif
    setLeafletCanNavigateBack               ,


-- ** canNavigateForward #attr:canNavigateForward#
-- | Whether gestures and shortcuts for navigating forward are enabled.
-- 
-- The supported gestures are:
-- 
-- * One-finger swipe on touchscreens
-- * Horizontal scrolling on touchpads (usually two-finger swipe)
-- * Back\/forward mouse buttons
-- 
-- 
-- The keyboard back\/forward keys are also supported, as well as the
-- \<kbd>Alt\<\/kbd>+\<kbd>→\<\/kbd> shortcut for horizontal orientation, or
-- \<kbd>Alt\<\/kbd>+\<kbd>↓\<\/kbd> for vertical orientation.
-- 
-- If the orientation is horizontal, for right-to-left locales, gestures and
-- shortcuts are reversed.
-- 
-- Only children that have [property/@leafletPage@/:navigatable] set to @TRUE@
-- can be navigated to.

#if defined(ENABLE_OVERLOADING)
    LeafletCanNavigateForwardPropertyInfo   ,
#endif
    constructLeafletCanNavigateForward      ,
    getLeafletCanNavigateForward            ,
#if defined(ENABLE_OVERLOADING)
    leafletCanNavigateForward               ,
#endif
    setLeafletCanNavigateForward            ,


-- ** canUnfold #attr:canUnfold#
-- | Whether or not the leaflet can unfold.

#if defined(ENABLE_OVERLOADING)
    LeafletCanUnfoldPropertyInfo            ,
#endif
    constructLeafletCanUnfold               ,
    getLeafletCanUnfold                     ,
#if defined(ENABLE_OVERLOADING)
    leafletCanUnfold                        ,
#endif
    setLeafletCanUnfold                     ,


-- ** childTransitionParams #attr:childTransitionParams#
-- | The child transition spring parameters.
-- 
-- The default value is equivalent to:
-- 
-- 
-- === /c code/
-- >adw_spring_params_new (1, 0.5, 500)

#if defined(ENABLE_OVERLOADING)
    LeafletChildTransitionParamsPropertyInfo,
#endif
    constructLeafletChildTransitionParams   ,
    getLeafletChildTransitionParams         ,
#if defined(ENABLE_OVERLOADING)
    leafletChildTransitionParams            ,
#endif
    setLeafletChildTransitionParams         ,


-- ** childTransitionRunning #attr:childTransitionRunning#
-- | Whether a child transition is currently running.

#if defined(ENABLE_OVERLOADING)
    LeafletChildTransitionRunningPropertyInfo,
#endif
    getLeafletChildTransitionRunning        ,
#if defined(ENABLE_OVERLOADING)
    leafletChildTransitionRunning           ,
#endif


-- ** foldThresholdPolicy #attr:foldThresholdPolicy#
-- | Determines when the leaflet will fold.
-- 
-- If set to @ADW_FOLD_THRESHOLD_POLICY_MINIMUM@, it will only fold when the
-- children cannot fit anymore. With @ADW_FOLD_THRESHOLD_POLICY_NATURAL@, it
-- will fold as soon as children don\'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 folding.

#if defined(ENABLE_OVERLOADING)
    LeafletFoldThresholdPolicyPropertyInfo  ,
#endif
    constructLeafletFoldThresholdPolicy     ,
    getLeafletFoldThresholdPolicy           ,
#if defined(ENABLE_OVERLOADING)
    leafletFoldThresholdPolicy              ,
#endif
    setLeafletFoldThresholdPolicy           ,


-- ** folded #attr:folded#
-- | Whether the leaflet is folded.
-- 
-- The leaflet will be folded if the size allocated to it is smaller than the
-- sum of the minimum or natural sizes of the children (see
-- [property/@leaflet@/:fold-threshold-policy]), it will be unfolded otherwise.

#if defined(ENABLE_OVERLOADING)
    LeafletFoldedPropertyInfo               ,
#endif
    getLeafletFolded                        ,
#if defined(ENABLE_OVERLOADING)
    leafletFolded                           ,
#endif


-- ** homogeneous #attr:homogeneous#
-- | Whether the leaflet allocates the same size for all children when folded.
-- 
-- If set to @FALSE@, different children can have different size along the
-- opposite orientation.

#if defined(ENABLE_OVERLOADING)
    LeafletHomogeneousPropertyInfo          ,
#endif
    constructLeafletHomogeneous             ,
    getLeafletHomogeneous                   ,
#if defined(ENABLE_OVERLOADING)
    leafletHomogeneous                      ,
#endif
    setLeafletHomogeneous                   ,


-- ** modeTransitionDuration #attr:modeTransitionDuration#
-- | The mode transition animation duration, in milliseconds.

#if defined(ENABLE_OVERLOADING)
    LeafletModeTransitionDurationPropertyInfo,
#endif
    constructLeafletModeTransitionDuration  ,
    getLeafletModeTransitionDuration        ,
#if defined(ENABLE_OVERLOADING)
    leafletModeTransitionDuration           ,
#endif
    setLeafletModeTransitionDuration        ,


-- ** pages #attr:pages#
-- | A selection model with the leaflet\'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 and change the visible
-- page.

#if defined(ENABLE_OVERLOADING)
    LeafletPagesPropertyInfo                ,
#endif
    getLeafletPages                         ,
#if defined(ENABLE_OVERLOADING)
    leafletPages                            ,
#endif


-- ** transitionType #attr:transitionType#
-- | The type of animation used for transitions between modes and children.
-- 
-- The transition type can be changed without problems at runtime, so it is
-- possible to change the animation based on the mode or child that is about
-- to become current.

#if defined(ENABLE_OVERLOADING)
    LeafletTransitionTypePropertyInfo       ,
#endif
    constructLeafletTransitionType          ,
    getLeafletTransitionType                ,
#if defined(ENABLE_OVERLOADING)
    leafletTransitionType                   ,
#endif
    setLeafletTransitionType                ,


-- ** visibleChild #attr:visibleChild#
-- | The widget currently visible when the leaflet is folded.
-- 
-- The transition is determined by [property/@leaflet@/:transition-type] and
-- [property/@leaflet@/:child-transition-params]. The transition can be cancelled
-- by the user, in which case visible child will change back to the previously
-- visible child.

#if defined(ENABLE_OVERLOADING)
    LeafletVisibleChildPropertyInfo         ,
#endif
    constructLeafletVisibleChild            ,
    getLeafletVisibleChild                  ,
#if defined(ENABLE_OVERLOADING)
    leafletVisibleChild                     ,
#endif
    setLeafletVisibleChild                  ,


-- ** visibleChildName #attr:visibleChildName#
-- | The name of the widget currently visible when the leaflet is folded.
-- 
-- See [property/@leaflet@/:visible-child].

#if defined(ENABLE_OVERLOADING)
    LeafletVisibleChildNamePropertyInfo     ,
#endif
    constructLeafletVisibleChildName        ,
    getLeafletVisibleChildName              ,
#if defined(ENABLE_OVERLOADING)
    leafletVisibleChildName                 ,
#endif
    setLeafletVisibleChildName              ,




    ) where

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

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

import {-# SOURCE #-} qualified GI.Adw.Enums as Adw.Enums
import {-# SOURCE #-} qualified GI.Adw.Interfaces.Swipeable as Adw.Swipeable
import {-# SOURCE #-} qualified GI.Adw.Objects.LeafletPage as Adw.LeafletPage
import {-# SOURCE #-} qualified GI.Adw.Structs.SpringParams as Adw.SpringParams
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 Leaflet = Leaflet (SP.ManagedPtr Leaflet)
    deriving (Leaflet -> Leaflet -> Bool
(Leaflet -> Leaflet -> Bool)
-> (Leaflet -> Leaflet -> Bool) -> Eq Leaflet
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Leaflet -> Leaflet -> Bool
== :: Leaflet -> Leaflet -> Bool
$c/= :: Leaflet -> Leaflet -> Bool
/= :: Leaflet -> Leaflet -> Bool
Eq)

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

foreign import ccall "adw_leaflet_get_type"
    c_adw_leaflet_get_type :: IO B.Types.GType

instance B.Types.TypedObject Leaflet where
    glibType :: IO GType
glibType = IO GType
c_adw_leaflet_get_type

instance B.Types.GObject Leaflet

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

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveLeafletMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveLeafletMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveLeafletMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveLeafletMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveLeafletMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveLeafletMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveLeafletMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveLeafletMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveLeafletMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveLeafletMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveLeafletMethod "append" o = LeafletAppendMethodInfo
    ResolveLeafletMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveLeafletMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveLeafletMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveLeafletMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveLeafletMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveLeafletMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveLeafletMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveLeafletMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveLeafletMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveLeafletMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveLeafletMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveLeafletMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveLeafletMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveLeafletMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveLeafletMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveLeafletMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveLeafletMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveLeafletMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveLeafletMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveLeafletMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveLeafletMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveLeafletMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveLeafletMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveLeafletMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveLeafletMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveLeafletMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveLeafletMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveLeafletMethod "insertChildAfter" o = LeafletInsertChildAfterMethodInfo
    ResolveLeafletMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveLeafletMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveLeafletMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveLeafletMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveLeafletMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveLeafletMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveLeafletMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveLeafletMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveLeafletMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveLeafletMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveLeafletMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveLeafletMethod "navigate" o = LeafletNavigateMethodInfo
    ResolveLeafletMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveLeafletMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveLeafletMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveLeafletMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveLeafletMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveLeafletMethod "prepend" o = LeafletPrependMethodInfo
    ResolveLeafletMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveLeafletMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveLeafletMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveLeafletMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveLeafletMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveLeafletMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveLeafletMethod "remove" o = LeafletRemoveMethodInfo
    ResolveLeafletMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveLeafletMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveLeafletMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveLeafletMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveLeafletMethod "reorderChildAfter" o = LeafletReorderChildAfterMethodInfo
    ResolveLeafletMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveLeafletMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveLeafletMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveLeafletMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveLeafletMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveLeafletMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveLeafletMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveLeafletMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveLeafletMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveLeafletMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveLeafletMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveLeafletMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveLeafletMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveLeafletMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveLeafletMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveLeafletMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveLeafletMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveLeafletMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveLeafletMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
    ResolveLeafletMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveLeafletMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveLeafletMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveLeafletMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveLeafletMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
    ResolveLeafletMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveLeafletMethod "getAdjacentChild" o = LeafletGetAdjacentChildMethodInfo
    ResolveLeafletMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveLeafletMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveLeafletMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveLeafletMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveLeafletMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveLeafletMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
    ResolveLeafletMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
    ResolveLeafletMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveLeafletMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveLeafletMethod "getCanNavigateBack" o = LeafletGetCanNavigateBackMethodInfo
    ResolveLeafletMethod "getCanNavigateForward" o = LeafletGetCanNavigateForwardMethodInfo
    ResolveLeafletMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveLeafletMethod "getCanUnfold" o = LeafletGetCanUnfoldMethodInfo
    ResolveLeafletMethod "getCancelProgress" o = Adw.Swipeable.SwipeableGetCancelProgressMethodInfo
    ResolveLeafletMethod "getChildByName" o = LeafletGetChildByNameMethodInfo
    ResolveLeafletMethod "getChildTransitionParams" o = LeafletGetChildTransitionParamsMethodInfo
    ResolveLeafletMethod "getChildTransitionRunning" o = LeafletGetChildTransitionRunningMethodInfo
    ResolveLeafletMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveLeafletMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveLeafletMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
    ResolveLeafletMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveLeafletMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveLeafletMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveLeafletMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveLeafletMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveLeafletMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveLeafletMethod "getDistance" o = Adw.Swipeable.SwipeableGetDistanceMethodInfo
    ResolveLeafletMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
    ResolveLeafletMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveLeafletMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveLeafletMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveLeafletMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveLeafletMethod "getFoldThresholdPolicy" o = LeafletGetFoldThresholdPolicyMethodInfo
    ResolveLeafletMethod "getFolded" o = LeafletGetFoldedMethodInfo
    ResolveLeafletMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveLeafletMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveLeafletMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveLeafletMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveLeafletMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveLeafletMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveLeafletMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveLeafletMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveLeafletMethod "getHomogeneous" o = LeafletGetHomogeneousMethodInfo
    ResolveLeafletMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveLeafletMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveLeafletMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveLeafletMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveLeafletMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveLeafletMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveLeafletMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveLeafletMethod "getModeTransitionDuration" o = LeafletGetModeTransitionDurationMethodInfo
    ResolveLeafletMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveLeafletMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveLeafletMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
    ResolveLeafletMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveLeafletMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveLeafletMethod "getOrientation" o = Gtk.Orientable.OrientableGetOrientationMethodInfo
    ResolveLeafletMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveLeafletMethod "getPage" o = LeafletGetPageMethodInfo
    ResolveLeafletMethod "getPages" o = LeafletGetPagesMethodInfo
    ResolveLeafletMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveLeafletMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveLeafletMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
    ResolveLeafletMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveLeafletMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveLeafletMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveLeafletMethod "getProgress" o = Adw.Swipeable.SwipeableGetProgressMethodInfo
    ResolveLeafletMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveLeafletMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveLeafletMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveLeafletMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveLeafletMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveLeafletMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveLeafletMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveLeafletMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveLeafletMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveLeafletMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveLeafletMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveLeafletMethod "getSnapPoints" o = Adw.Swipeable.SwipeableGetSnapPointsMethodInfo
    ResolveLeafletMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveLeafletMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveLeafletMethod "getSwipeArea" o = Adw.Swipeable.SwipeableGetSwipeAreaMethodInfo
    ResolveLeafletMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveLeafletMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveLeafletMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveLeafletMethod "getTransitionType" o = LeafletGetTransitionTypeMethodInfo
    ResolveLeafletMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveLeafletMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveLeafletMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveLeafletMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveLeafletMethod "getVisibleChild" o = LeafletGetVisibleChildMethodInfo
    ResolveLeafletMethod "getVisibleChildName" o = LeafletGetVisibleChildNameMethodInfo
    ResolveLeafletMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveLeafletMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
    ResolveLeafletMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveLeafletMethod "setCanNavigateBack" o = LeafletSetCanNavigateBackMethodInfo
    ResolveLeafletMethod "setCanNavigateForward" o = LeafletSetCanNavigateForwardMethodInfo
    ResolveLeafletMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveLeafletMethod "setCanUnfold" o = LeafletSetCanUnfoldMethodInfo
    ResolveLeafletMethod "setChildTransitionParams" o = LeafletSetChildTransitionParamsMethodInfo
    ResolveLeafletMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveLeafletMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveLeafletMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveLeafletMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveLeafletMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveLeafletMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveLeafletMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveLeafletMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveLeafletMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveLeafletMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveLeafletMethod "setFoldThresholdPolicy" o = LeafletSetFoldThresholdPolicyMethodInfo
    ResolveLeafletMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveLeafletMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveLeafletMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveLeafletMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveLeafletMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveLeafletMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveLeafletMethod "setHomogeneous" o = LeafletSetHomogeneousMethodInfo
    ResolveLeafletMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveLeafletMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveLeafletMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveLeafletMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveLeafletMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveLeafletMethod "setModeTransitionDuration" o = LeafletSetModeTransitionDurationMethodInfo
    ResolveLeafletMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveLeafletMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveLeafletMethod "setOrientation" o = Gtk.Orientable.OrientableSetOrientationMethodInfo
    ResolveLeafletMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveLeafletMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveLeafletMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveLeafletMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveLeafletMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveLeafletMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveLeafletMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveLeafletMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveLeafletMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveLeafletMethod "setTransitionType" o = LeafletSetTransitionTypeMethodInfo
    ResolveLeafletMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveLeafletMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveLeafletMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveLeafletMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveLeafletMethod "setVisibleChild" o = LeafletSetVisibleChildMethodInfo
    ResolveLeafletMethod "setVisibleChildName" o = LeafletSetVisibleChildNameMethodInfo
    ResolveLeafletMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

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

-- | Get the value of the “@can-navigate-back@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' leaflet #canNavigateBack
-- @
getLeafletCanNavigateBack :: (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletCanNavigateBack :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletCanNavigateBack o
obj = IO Bool -> m Bool
forall a. IO a -> m a
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
"can-navigate-back"

-- | Set the value of the “@can-navigate-back@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' leaflet [ #canNavigateBack 'Data.GI.Base.Attributes.:=' value ]
-- @
setLeafletCanNavigateBack :: (MonadIO m, IsLeaflet o) => o -> Bool -> m ()
setLeafletCanNavigateBack :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> Bool -> m ()
setLeafletCanNavigateBack o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"can-navigate-back" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data LeafletCanNavigateBackPropertyInfo
instance AttrInfo LeafletCanNavigateBackPropertyInfo where
    type AttrAllowedOps LeafletCanNavigateBackPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletCanNavigateBackPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletCanNavigateBackPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint LeafletCanNavigateBackPropertyInfo = (~) Bool
    type AttrTransferType LeafletCanNavigateBackPropertyInfo = Bool
    type AttrGetType LeafletCanNavigateBackPropertyInfo = Bool
    type AttrLabel LeafletCanNavigateBackPropertyInfo = "can-navigate-back"
    type AttrOrigin LeafletCanNavigateBackPropertyInfo = Leaflet
    attrGet = getLeafletCanNavigateBack
    attrSet = setLeafletCanNavigateBack
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletCanNavigateBack
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Leaflet.canNavigateBack"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-Leaflet.html#g:attr:canNavigateBack"
        })
#endif

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

-- | Get the value of the “@can-navigate-forward@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' leaflet #canNavigateForward
-- @
getLeafletCanNavigateForward :: (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletCanNavigateForward :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletCanNavigateForward o
obj = IO Bool -> m Bool
forall a. IO a -> m a
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
"can-navigate-forward"

-- | Set the value of the “@can-navigate-forward@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' leaflet [ #canNavigateForward 'Data.GI.Base.Attributes.:=' value ]
-- @
setLeafletCanNavigateForward :: (MonadIO m, IsLeaflet o) => o -> Bool -> m ()
setLeafletCanNavigateForward :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> Bool -> m ()
setLeafletCanNavigateForward o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"can-navigate-forward" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data LeafletCanNavigateForwardPropertyInfo
instance AttrInfo LeafletCanNavigateForwardPropertyInfo where
    type AttrAllowedOps LeafletCanNavigateForwardPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletCanNavigateForwardPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletCanNavigateForwardPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint LeafletCanNavigateForwardPropertyInfo = (~) Bool
    type AttrTransferType LeafletCanNavigateForwardPropertyInfo = Bool
    type AttrGetType LeafletCanNavigateForwardPropertyInfo = Bool
    type AttrLabel LeafletCanNavigateForwardPropertyInfo = "can-navigate-forward"
    type AttrOrigin LeafletCanNavigateForwardPropertyInfo = Leaflet
    attrGet = getLeafletCanNavigateForward
    attrSet = setLeafletCanNavigateForward
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletCanNavigateForward
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Leaflet.canNavigateForward"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-Leaflet.html#g:attr:canNavigateForward"
        })
#endif

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

-- | Get the value of the “@can-unfold@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' leaflet #canUnfold
-- @
getLeafletCanUnfold :: (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletCanUnfold :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletCanUnfold o
obj = IO Bool -> m Bool
forall a. IO a -> m a
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
"can-unfold"

-- | Set the value of the “@can-unfold@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' leaflet [ #canUnfold 'Data.GI.Base.Attributes.:=' value ]
-- @
setLeafletCanUnfold :: (MonadIO m, IsLeaflet o) => o -> Bool -> m ()
setLeafletCanUnfold :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> Bool -> m ()
setLeafletCanUnfold o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"can-unfold" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data LeafletCanUnfoldPropertyInfo
instance AttrInfo LeafletCanUnfoldPropertyInfo where
    type AttrAllowedOps LeafletCanUnfoldPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletCanUnfoldPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletCanUnfoldPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint LeafletCanUnfoldPropertyInfo = (~) Bool
    type AttrTransferType LeafletCanUnfoldPropertyInfo = Bool
    type AttrGetType LeafletCanUnfoldPropertyInfo = Bool
    type AttrLabel LeafletCanUnfoldPropertyInfo = "can-unfold"
    type AttrOrigin LeafletCanUnfoldPropertyInfo = Leaflet
    attrGet = getLeafletCanUnfold
    attrSet = setLeafletCanUnfold
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletCanUnfold
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Leaflet.canUnfold"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-Leaflet.html#g:attr:canUnfold"
        })
#endif

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

-- | Get the value of the “@child-transition-params@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' leaflet #childTransitionParams
-- @
getLeafletChildTransitionParams :: (MonadIO m, IsLeaflet o) => o -> m (Maybe Adw.SpringParams.SpringParams)
getLeafletChildTransitionParams :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> m (Maybe SpringParams)
getLeafletChildTransitionParams o
obj = IO (Maybe SpringParams) -> m (Maybe SpringParams)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe SpringParams) -> m (Maybe SpringParams))
-> IO (Maybe SpringParams) -> m (Maybe SpringParams)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr SpringParams -> SpringParams)
-> IO (Maybe SpringParams)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"child-transition-params" ManagedPtr SpringParams -> SpringParams
Adw.SpringParams.SpringParams

-- | Set the value of the “@child-transition-params@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' leaflet [ #childTransitionParams 'Data.GI.Base.Attributes.:=' value ]
-- @
setLeafletChildTransitionParams :: (MonadIO m, IsLeaflet o) => o -> Adw.SpringParams.SpringParams -> m ()
setLeafletChildTransitionParams :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> SpringParams -> m ()
setLeafletChildTransitionParams o
obj SpringParams
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe SpringParams -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"child-transition-params" (SpringParams -> Maybe SpringParams
forall a. a -> Maybe a
Just SpringParams
val)

-- | Construct a `GValueConstruct` with valid value for the “@child-transition-params@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructLeafletChildTransitionParams :: (IsLeaflet o, MIO.MonadIO m) => Adw.SpringParams.SpringParams -> m (GValueConstruct o)
constructLeafletChildTransitionParams :: forall o (m :: * -> *).
(IsLeaflet o, MonadIO m) =>
SpringParams -> m (GValueConstruct o)
constructLeafletChildTransitionParams SpringParams
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe SpringParams -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"child-transition-params" (SpringParams -> Maybe SpringParams
forall a. a -> Maybe a
P.Just SpringParams
val)

#if defined(ENABLE_OVERLOADING)
data LeafletChildTransitionParamsPropertyInfo
instance AttrInfo LeafletChildTransitionParamsPropertyInfo where
    type AttrAllowedOps LeafletChildTransitionParamsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletChildTransitionParamsPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletChildTransitionParamsPropertyInfo = (~) Adw.SpringParams.SpringParams
    type AttrTransferTypeConstraint LeafletChildTransitionParamsPropertyInfo = (~) Adw.SpringParams.SpringParams
    type AttrTransferType LeafletChildTransitionParamsPropertyInfo = Adw.SpringParams.SpringParams
    type AttrGetType LeafletChildTransitionParamsPropertyInfo = (Maybe Adw.SpringParams.SpringParams)
    type AttrLabel LeafletChildTransitionParamsPropertyInfo = "child-transition-params"
    type AttrOrigin LeafletChildTransitionParamsPropertyInfo = Leaflet
    attrGet = getLeafletChildTransitionParams
    attrSet = setLeafletChildTransitionParams
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletChildTransitionParams
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Leaflet.childTransitionParams"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-Leaflet.html#g:attr:childTransitionParams"
        })
#endif

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

-- | Get the value of the “@child-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' leaflet #childTransitionRunning
-- @
getLeafletChildTransitionRunning :: (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletChildTransitionRunning :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletChildTransitionRunning o
obj = IO Bool -> m Bool
forall a. IO a -> m a
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
"child-transition-running"

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

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

-- | Get the value of the “@fold-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' leaflet #foldThresholdPolicy
-- @
getLeafletFoldThresholdPolicy :: (MonadIO m, IsLeaflet o) => o -> m Adw.Enums.FoldThresholdPolicy
getLeafletFoldThresholdPolicy :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> m FoldThresholdPolicy
getLeafletFoldThresholdPolicy o
obj = IO FoldThresholdPolicy -> m FoldThresholdPolicy
forall a. IO a -> m a
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
"fold-threshold-policy"

-- | Set the value of the “@fold-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' leaflet [ #foldThresholdPolicy 'Data.GI.Base.Attributes.:=' value ]
-- @
setLeafletFoldThresholdPolicy :: (MonadIO m, IsLeaflet o) => o -> Adw.Enums.FoldThresholdPolicy -> m ()
setLeafletFoldThresholdPolicy :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> FoldThresholdPolicy -> m ()
setLeafletFoldThresholdPolicy o
obj FoldThresholdPolicy
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> FoldThresholdPolicy -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"fold-threshold-policy" FoldThresholdPolicy
val

-- | Construct a `GValueConstruct` with valid value for the “@fold-threshold-policy@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructLeafletFoldThresholdPolicy :: (IsLeaflet o, MIO.MonadIO m) => Adw.Enums.FoldThresholdPolicy -> m (GValueConstruct o)
constructLeafletFoldThresholdPolicy :: forall o (m :: * -> *).
(IsLeaflet o, MonadIO m) =>
FoldThresholdPolicy -> m (GValueConstruct o)
constructLeafletFoldThresholdPolicy FoldThresholdPolicy
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> FoldThresholdPolicy -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"fold-threshold-policy" FoldThresholdPolicy
val

#if defined(ENABLE_OVERLOADING)
data LeafletFoldThresholdPolicyPropertyInfo
instance AttrInfo LeafletFoldThresholdPolicyPropertyInfo where
    type AttrAllowedOps LeafletFoldThresholdPolicyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletFoldThresholdPolicyPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletFoldThresholdPolicyPropertyInfo = (~) Adw.Enums.FoldThresholdPolicy
    type AttrTransferTypeConstraint LeafletFoldThresholdPolicyPropertyInfo = (~) Adw.Enums.FoldThresholdPolicy
    type AttrTransferType LeafletFoldThresholdPolicyPropertyInfo = Adw.Enums.FoldThresholdPolicy
    type AttrGetType LeafletFoldThresholdPolicyPropertyInfo = Adw.Enums.FoldThresholdPolicy
    type AttrLabel LeafletFoldThresholdPolicyPropertyInfo = "fold-threshold-policy"
    type AttrOrigin LeafletFoldThresholdPolicyPropertyInfo = Leaflet
    attrGet = getLeafletFoldThresholdPolicy
    attrSet = setLeafletFoldThresholdPolicy
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletFoldThresholdPolicy
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Leaflet.foldThresholdPolicy"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-Leaflet.html#g:attr:foldThresholdPolicy"
        })
#endif

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

-- | Get the value of the “@folded@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' leaflet #folded
-- @
getLeafletFolded :: (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletFolded :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletFolded o
obj = IO Bool -> m Bool
forall a. IO a -> m a
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
"folded"

#if defined(ENABLE_OVERLOADING)
data LeafletFoldedPropertyInfo
instance AttrInfo LeafletFoldedPropertyInfo where
    type AttrAllowedOps LeafletFoldedPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint LeafletFoldedPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletFoldedPropertyInfo = (~) ()
    type AttrTransferTypeConstraint LeafletFoldedPropertyInfo = (~) ()
    type AttrTransferType LeafletFoldedPropertyInfo = ()
    type AttrGetType LeafletFoldedPropertyInfo = Bool
    type AttrLabel LeafletFoldedPropertyInfo = "folded"
    type AttrOrigin LeafletFoldedPropertyInfo = Leaflet
    attrGet = getLeafletFolded
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Leaflet.folded"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-Leaflet.html#g:attr:folded"
        })
#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' leaflet #homogeneous
-- @
getLeafletHomogeneous :: (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletHomogeneous :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletHomogeneous o
obj = IO Bool -> m Bool
forall a. IO a -> m a
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' leaflet [ #homogeneous 'Data.GI.Base.Attributes.:=' value ]
-- @
setLeafletHomogeneous :: (MonadIO m, IsLeaflet o) => o -> Bool -> m ()
setLeafletHomogeneous :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> Bool -> m ()
setLeafletHomogeneous o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> 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`.
constructLeafletHomogeneous :: (IsLeaflet o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructLeafletHomogeneous :: forall o (m :: * -> *).
(IsLeaflet o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructLeafletHomogeneous Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"homogeneous" Bool
val

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

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

-- | Get the value of the “@mode-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' leaflet #modeTransitionDuration
-- @
getLeafletModeTransitionDuration :: (MonadIO m, IsLeaflet o) => o -> m Word32
getLeafletModeTransitionDuration :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Word32
getLeafletModeTransitionDuration o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
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
"mode-transition-duration"

-- | Set the value of the “@mode-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' leaflet [ #modeTransitionDuration 'Data.GI.Base.Attributes.:=' value ]
-- @
setLeafletModeTransitionDuration :: (MonadIO m, IsLeaflet o) => o -> Word32 -> m ()
setLeafletModeTransitionDuration :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> Word32 -> m ()
setLeafletModeTransitionDuration o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"mode-transition-duration" Word32
val

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

#if defined(ENABLE_OVERLOADING)
data LeafletModeTransitionDurationPropertyInfo
instance AttrInfo LeafletModeTransitionDurationPropertyInfo where
    type AttrAllowedOps LeafletModeTransitionDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletModeTransitionDurationPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletModeTransitionDurationPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint LeafletModeTransitionDurationPropertyInfo = (~) Word32
    type AttrTransferType LeafletModeTransitionDurationPropertyInfo = Word32
    type AttrGetType LeafletModeTransitionDurationPropertyInfo = Word32
    type AttrLabel LeafletModeTransitionDurationPropertyInfo = "mode-transition-duration"
    type AttrOrigin LeafletModeTransitionDurationPropertyInfo = Leaflet
    attrGet = getLeafletModeTransitionDuration
    attrSet = setLeafletModeTransitionDuration
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletModeTransitionDuration
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Leaflet.modeTransitionDuration"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-Leaflet.html#g:attr:modeTransitionDuration"
        })
#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' leaflet #pages
-- @
getLeafletPages :: (MonadIO m, IsLeaflet o) => o -> m (Maybe Gtk.SelectionModel.SelectionModel)
getLeafletPages :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> m (Maybe SelectionModel)
getLeafletPages o
obj = IO (Maybe SelectionModel) -> m (Maybe SelectionModel)
forall a. IO a -> m a
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 LeafletPagesPropertyInfo
instance AttrInfo LeafletPagesPropertyInfo where
    type AttrAllowedOps LeafletPagesPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint LeafletPagesPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletPagesPropertyInfo = (~) ()
    type AttrTransferTypeConstraint LeafletPagesPropertyInfo = (~) ()
    type AttrTransferType LeafletPagesPropertyInfo = ()
    type AttrGetType LeafletPagesPropertyInfo = (Maybe Gtk.SelectionModel.SelectionModel)
    type AttrLabel LeafletPagesPropertyInfo = "pages"
    type AttrOrigin LeafletPagesPropertyInfo = Leaflet
    attrGet = getLeafletPages
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Leaflet.pages"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-Leaflet.html#g:attr:pages"
        })
#endif

-- VVV Prop "transition-type"
   -- Type: TInterface (Name {namespace = "Adw", name = "LeafletTransitionType"})
   -- 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' leaflet #transitionType
-- @
getLeafletTransitionType :: (MonadIO m, IsLeaflet o) => o -> m Adw.Enums.LeafletTransitionType
getLeafletTransitionType :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> m LeafletTransitionType
getLeafletTransitionType o
obj = IO LeafletTransitionType -> m LeafletTransitionType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO LeafletTransitionType -> m LeafletTransitionType)
-> IO LeafletTransitionType -> m LeafletTransitionType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO LeafletTransitionType
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' leaflet [ #transitionType 'Data.GI.Base.Attributes.:=' value ]
-- @
setLeafletTransitionType :: (MonadIO m, IsLeaflet o) => o -> Adw.Enums.LeafletTransitionType -> m ()
setLeafletTransitionType :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> LeafletTransitionType -> m ()
setLeafletTransitionType o
obj LeafletTransitionType
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> LeafletTransitionType -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"transition-type" LeafletTransitionType
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`.
constructLeafletTransitionType :: (IsLeaflet o, MIO.MonadIO m) => Adw.Enums.LeafletTransitionType -> m (GValueConstruct o)
constructLeafletTransitionType :: forall o (m :: * -> *).
(IsLeaflet o, MonadIO m) =>
LeafletTransitionType -> m (GValueConstruct o)
constructLeafletTransitionType LeafletTransitionType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> LeafletTransitionType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"transition-type" LeafletTransitionType
val

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

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

-- | 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' leaflet #visibleChild
-- @
getLeafletVisibleChild :: (MonadIO m, IsLeaflet o) => o -> m (Maybe Gtk.Widget.Widget)
getLeafletVisibleChild :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> m (Maybe Widget)
getLeafletVisibleChild o
obj = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Widget -> Widget) -> IO (Maybe Widget)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"visible-child" ManagedPtr Widget -> Widget
Gtk.Widget.Widget

-- | Set 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.set' leaflet [ #visibleChild 'Data.GI.Base.Attributes.:=' value ]
-- @
setLeafletVisibleChild :: (MonadIO m, IsLeaflet o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setLeafletVisibleChild :: forall (m :: * -> *) o a.
(MonadIO m, IsLeaflet o, IsWidget a) =>
o -> a -> m ()
setLeafletVisibleChild o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"visible-child" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

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

#if defined(ENABLE_OVERLOADING)
data LeafletVisibleChildPropertyInfo
instance AttrInfo LeafletVisibleChildPropertyInfo where
    type AttrAllowedOps LeafletVisibleChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletVisibleChildPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletVisibleChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint LeafletVisibleChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType LeafletVisibleChildPropertyInfo = Gtk.Widget.Widget
    type AttrGetType LeafletVisibleChildPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel LeafletVisibleChildPropertyInfo = "visible-child"
    type AttrOrigin LeafletVisibleChildPropertyInfo = Leaflet
    attrGet = getLeafletVisibleChild
    attrSet = setLeafletVisibleChild
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructLeafletVisibleChild
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Leaflet.visibleChild"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-Leaflet.html#g:attr:visibleChild"
        })
#endif

-- VVV Prop "visible-child-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just False)

-- | Get the value of the “@visible-child-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' leaflet #visibleChildName
-- @
getLeafletVisibleChildName :: (MonadIO m, IsLeaflet o) => o -> m (Maybe T.Text)
getLeafletVisibleChildName :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> m (Maybe Text)
getLeafletVisibleChildName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"visible-child-name"

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

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

#if defined(ENABLE_OVERLOADING)
data LeafletVisibleChildNamePropertyInfo
instance AttrInfo LeafletVisibleChildNamePropertyInfo where
    type AttrAllowedOps LeafletVisibleChildNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletVisibleChildNamePropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletVisibleChildNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint LeafletVisibleChildNamePropertyInfo = (~) T.Text
    type AttrTransferType LeafletVisibleChildNamePropertyInfo = T.Text
    type AttrGetType LeafletVisibleChildNamePropertyInfo = (Maybe T.Text)
    type AttrLabel LeafletVisibleChildNamePropertyInfo = "visible-child-name"
    type AttrOrigin LeafletVisibleChildNamePropertyInfo = Leaflet
    attrGet = getLeafletVisibleChildName
    attrSet = setLeafletVisibleChildName
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletVisibleChildName
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Leaflet.visibleChildName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-Leaflet.html#g:attr:visibleChildName"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Leaflet
type instance O.AttributeList Leaflet = LeafletAttributeList
type LeafletAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canNavigateBack", LeafletCanNavigateBackPropertyInfo), '("canNavigateForward", LeafletCanNavigateForwardPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("canUnfold", LeafletCanUnfoldPropertyInfo), '("childTransitionParams", LeafletChildTransitionParamsPropertyInfo), '("childTransitionRunning", LeafletChildTransitionRunningPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("foldThresholdPolicy", LeafletFoldThresholdPolicyPropertyInfo), '("folded", LeafletFoldedPropertyInfo), '("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", LeafletHomogeneousPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("modeTransitionDuration", LeafletModeTransitionDurationPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("orientation", Gtk.Orientable.OrientableOrientationPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("pages", LeafletPagesPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("transitionType", LeafletTransitionTypePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("visibleChild", LeafletVisibleChildPropertyInfo), '("visibleChildName", LeafletVisibleChildNamePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
leafletCanNavigateBack :: AttrLabelProxy "canNavigateBack"
leafletCanNavigateBack = AttrLabelProxy

leafletCanNavigateForward :: AttrLabelProxy "canNavigateForward"
leafletCanNavigateForward = AttrLabelProxy

leafletCanUnfold :: AttrLabelProxy "canUnfold"
leafletCanUnfold = AttrLabelProxy

leafletChildTransitionParams :: AttrLabelProxy "childTransitionParams"
leafletChildTransitionParams = AttrLabelProxy

leafletChildTransitionRunning :: AttrLabelProxy "childTransitionRunning"
leafletChildTransitionRunning = AttrLabelProxy

leafletFoldThresholdPolicy :: AttrLabelProxy "foldThresholdPolicy"
leafletFoldThresholdPolicy = AttrLabelProxy

leafletFolded :: AttrLabelProxy "folded"
leafletFolded = AttrLabelProxy

leafletHomogeneous :: AttrLabelProxy "homogeneous"
leafletHomogeneous = AttrLabelProxy

leafletModeTransitionDuration :: AttrLabelProxy "modeTransitionDuration"
leafletModeTransitionDuration = AttrLabelProxy

leafletPages :: AttrLabelProxy "pages"
leafletPages = AttrLabelProxy

leafletTransitionType :: AttrLabelProxy "transitionType"
leafletTransitionType = AttrLabelProxy

leafletVisibleChild :: AttrLabelProxy "visibleChild"
leafletVisibleChild = AttrLabelProxy

leafletVisibleChildName :: AttrLabelProxy "visibleChildName"
leafletVisibleChildName = AttrLabelProxy

#endif

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

#endif

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

foreign import ccall "adw_leaflet_new" adw_leaflet_new :: 
    IO (Ptr Leaflet)

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

#if defined(ENABLE_OVERLOADING)
#endif

-- method Leaflet::append
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , 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 = "LeafletPage" })
-- throws : False
-- Skip return : False

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

-- | Adds a child to /@self@/.
leafletAppend ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a leaflet
    -> b
    -- ^ /@child@/: the widget to add
    -> m Adw.LeafletPage.LeafletPage
    -- ^ __Returns:__ the [class/@leafletPage@/] for /@child@/
leafletAppend :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsLeaflet a, IsWidget b) =>
a -> b -> m LeafletPage
leafletAppend a
self b
child = IO LeafletPage -> m LeafletPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LeafletPage -> m LeafletPage)
-> IO LeafletPage -> m LeafletPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
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 LeafletPage
result <- Ptr Leaflet -> Ptr Widget -> IO (Ptr LeafletPage)
adw_leaflet_append Ptr Leaflet
self' Ptr Widget
child'
    Text -> Ptr LeafletPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"leafletAppend" Ptr LeafletPage
result
    LeafletPage
result' <- ((ManagedPtr LeafletPage -> LeafletPage)
-> Ptr LeafletPage -> IO LeafletPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr LeafletPage -> LeafletPage
Adw.LeafletPage.LeafletPage) Ptr LeafletPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    LeafletPage -> IO LeafletPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LeafletPage
result'

#if defined(ENABLE_OVERLOADING)
data LeafletAppendMethodInfo
instance (signature ~ (b -> m Adw.LeafletPage.LeafletPage), MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b) => O.OverloadedMethod LeafletAppendMethodInfo a signature where
    overloadedMethod = leafletAppend

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


#endif

-- method Leaflet::get_adjacent_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "direction"
--           , argType =
--               TInterface
--                 Name { namespace = "Adw" , name = "NavigationDirection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the direction" , 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_leaflet_get_adjacent_child" adw_leaflet_get_adjacent_child :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    CUInt ->                                -- direction : TInterface (Name {namespace = "Adw", name = "NavigationDirection"})
    IO (Ptr Gtk.Widget.Widget)

-- | Finds the previous or next navigatable child.
-- 
-- This will be the same child [method/@leaflet@/.navigate] or swipe gestures will
-- navigate to.
-- 
-- If there\'s no child to navigate to, @NULL@ will be returned instead.
-- 
-- See [property/@leafletPage@/:navigatable].
leafletGetAdjacentChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> Adw.Enums.NavigationDirection
    -- ^ /@direction@/: the direction
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the previous or next child
leafletGetAdjacentChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> NavigationDirection -> m (Maybe Widget)
leafletGetAdjacentChild a
self NavigationDirection
direction = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let direction' :: CUInt
direction' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (NavigationDirection -> Int) -> NavigationDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NavigationDirection -> Int
forall a. Enum a => a -> Int
fromEnum) NavigationDirection
direction
    Ptr Widget
result <- Ptr Leaflet -> CUInt -> IO (Ptr Widget)
adw_leaflet_get_adjacent_child Ptr Leaflet
self' CUInt
direction'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(ENABLE_OVERLOADING)
data LeafletGetAdjacentChildMethodInfo
instance (signature ~ (Adw.Enums.NavigationDirection -> m (Maybe Gtk.Widget.Widget)), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetAdjacentChildMethodInfo a signature where
    overloadedMethod = leafletGetAdjacentChild

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


#endif

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

-- | Gets whether gestures and shortcuts for navigating backward are enabled.
leafletGetCanNavigateBack ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m Bool
    -- ^ __Returns:__ Whether gestures and shortcuts are enabled.
leafletGetCanNavigateBack :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Bool
leafletGetCanNavigateBack a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Leaflet -> IO CInt
adw_leaflet_get_can_navigate_back Ptr Leaflet
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetCanNavigateBackMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetCanNavigateBackMethodInfo a signature where
    overloadedMethod = leafletGetCanNavigateBack

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


#endif

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

-- | Gets whether gestures and shortcuts for navigating forward are enabled.
leafletGetCanNavigateForward ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m Bool
    -- ^ __Returns:__ Whether gestures and shortcuts are enabled.
leafletGetCanNavigateForward :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Bool
leafletGetCanNavigateForward a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Leaflet -> IO CInt
adw_leaflet_get_can_navigate_forward Ptr Leaflet
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetCanNavigateForwardMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetCanNavigateForwardMethodInfo a signature where
    overloadedMethod = leafletGetCanNavigateForward

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


#endif

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

-- | Gets whether /@self@/ can unfold.
leafletGetCanUnfold ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ can unfold
leafletGetCanUnfold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Bool
leafletGetCanUnfold a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Leaflet -> IO CInt
adw_leaflet_get_can_unfold Ptr Leaflet
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetCanUnfoldMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetCanUnfoldMethodInfo a signature where
    overloadedMethod = leafletGetCanUnfold

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


#endif

-- method Leaflet::get_child_by_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the child to find"
--                 , 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_leaflet_get_child_by_name" adw_leaflet_get_child_by_name :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr Gtk.Widget.Widget)

-- | Finds the child of /@self@/ with /@name@/.
-- 
-- Returns @NULL@ if there is no child with this name.
-- 
-- See [property/@leafletPage@/:name].
leafletGetChildByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> T.Text
    -- ^ /@name@/: the name of the child to find
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the requested child of /@self@/
leafletGetChildByName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Text -> m (Maybe Widget)
leafletGetChildByName a
self Text
name = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Widget
result <- Ptr Leaflet -> CString -> IO (Ptr Widget)
adw_leaflet_get_child_by_name Ptr Leaflet
self' CString
name'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(ENABLE_OVERLOADING)
data LeafletGetChildByNameMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gtk.Widget.Widget)), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetChildByNameMethodInfo a signature where
    overloadedMethod = leafletGetChildByName

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


#endif

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

foreign import ccall "adw_leaflet_get_child_transition_params" adw_leaflet_get_child_transition_params :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    IO (Ptr Adw.SpringParams.SpringParams)

-- | Gets the child transition spring parameters for /@self@/.
leafletGetChildTransitionParams ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m Adw.SpringParams.SpringParams
    -- ^ __Returns:__ the child transition parameters
leafletGetChildTransitionParams :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m SpringParams
leafletGetChildTransitionParams a
self = IO SpringParams -> m SpringParams
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SpringParams -> m SpringParams)
-> IO SpringParams -> m SpringParams
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SpringParams
result <- Ptr Leaflet -> IO (Ptr SpringParams)
adw_leaflet_get_child_transition_params Ptr Leaflet
self'
    Text -> Ptr SpringParams -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"leafletGetChildTransitionParams" Ptr SpringParams
result
    SpringParams
result' <- ((ManagedPtr SpringParams -> SpringParams)
-> Ptr SpringParams -> IO SpringParams
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr SpringParams -> SpringParams
Adw.SpringParams.SpringParams) Ptr SpringParams
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    SpringParams -> IO SpringParams
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SpringParams
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetChildTransitionParamsMethodInfo
instance (signature ~ (m Adw.SpringParams.SpringParams), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetChildTransitionParamsMethodInfo a signature where
    overloadedMethod = leafletGetChildTransitionParams

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


#endif

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

-- | Gets whether a child transition is currently running for /@self@/.
leafletGetChildTransitionRunning ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m Bool
    -- ^ __Returns:__ whether a transition is currently running
leafletGetChildTransitionRunning :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Bool
leafletGetChildTransitionRunning a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Leaflet -> IO CInt
adw_leaflet_get_child_transition_running Ptr Leaflet
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetChildTransitionRunningMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetChildTransitionRunningMethodInfo a signature where
    overloadedMethod = leafletGetChildTransitionRunning

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


#endif

-- method Leaflet::get_fold_threshold_policy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , 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_leaflet_get_fold_threshold_policy" adw_leaflet_get_fold_threshold_policy :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    IO CUInt

-- | Gets the fold threshold policy for /@self@/.
leafletGetFoldThresholdPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m Adw.Enums.FoldThresholdPolicy
leafletGetFoldThresholdPolicy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m FoldThresholdPolicy
leafletGetFoldThresholdPolicy a
self = IO FoldThresholdPolicy -> m FoldThresholdPolicy
forall a. IO a -> m a
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 Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Leaflet -> IO CUInt
adw_leaflet_get_fold_threshold_policy Ptr Leaflet
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FoldThresholdPolicy
result'

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

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


#endif

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

-- | Gets whether /@self@/ is folded.
-- 
-- The leaflet will be folded if the size allocated to it is smaller than the
-- sum of the minimum or natural sizes of the children (see
-- [property/@leaflet@/:fold-threshold-policy]), it will be unfolded otherwise.
leafletGetFolded ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ is folded.
leafletGetFolded :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Bool
leafletGetFolded a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Leaflet -> IO CInt
adw_leaflet_get_folded Ptr Leaflet
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetFoldedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetFoldedMethodInfo a signature where
    overloadedMethod = leafletGetFolded

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


#endif

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

-- | Gets whether /@self@/ is homogeneous.
leafletGetHomogeneous ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ is homogeneous
leafletGetHomogeneous :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Bool
leafletGetHomogeneous a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Leaflet -> IO CInt
adw_leaflet_get_homogeneous Ptr Leaflet
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetHomogeneousMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetHomogeneousMethodInfo a signature where
    overloadedMethod = leafletGetHomogeneous

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


#endif

-- method Leaflet::get_mode_transition_duration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , 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_leaflet_get_mode_transition_duration" adw_leaflet_get_mode_transition_duration :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    IO Word32

-- | Gets the mode transition animation duration for /@self@/.
leafletGetModeTransitionDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m Word32
    -- ^ __Returns:__ the mode transition duration, in milliseconds.
leafletGetModeTransitionDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Word32
leafletGetModeTransitionDuration a
self = IO Word32 -> m Word32
forall a. IO a -> m a
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 Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Leaflet -> IO Word32
adw_leaflet_get_mode_transition_duration Ptr Leaflet
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data LeafletGetModeTransitionDurationMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetModeTransitionDurationMethodInfo a signature where
    overloadedMethod = leafletGetModeTransitionDuration

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


#endif

-- method Leaflet::get_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , 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 = "LeafletPage" })
-- throws : False
-- Skip return : False

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

-- | Returns the [class/@leafletPage@/] object for /@child@/.
leafletGetPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a leaflet
    -> b
    -- ^ /@child@/: a child of /@self@/
    -> m Adw.LeafletPage.LeafletPage
    -- ^ __Returns:__ the page object for /@child@/
leafletGetPage :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsLeaflet a, IsWidget b) =>
a -> b -> m LeafletPage
leafletGetPage a
self b
child = IO LeafletPage -> m LeafletPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LeafletPage -> m LeafletPage)
-> IO LeafletPage -> m LeafletPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
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 LeafletPage
result <- Ptr Leaflet -> Ptr Widget -> IO (Ptr LeafletPage)
adw_leaflet_get_page Ptr Leaflet
self' Ptr Widget
child'
    Text -> Ptr LeafletPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"leafletGetPage" Ptr LeafletPage
result
    LeafletPage
result' <- ((ManagedPtr LeafletPage -> LeafletPage)
-> Ptr LeafletPage -> IO LeafletPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr LeafletPage -> LeafletPage
Adw.LeafletPage.LeafletPage) Ptr LeafletPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    LeafletPage -> IO LeafletPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LeafletPage
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetPageMethodInfo
instance (signature ~ (b -> m Adw.LeafletPage.LeafletPage), MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b) => O.OverloadedMethod LeafletGetPageMethodInfo a signature where
    overloadedMethod = leafletGetPage

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


#endif

-- method Leaflet::get_pages
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , 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_leaflet_get_pages" adw_leaflet_get_pages :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    IO (Ptr Gtk.SelectionModel.SelectionModel)

-- | Returns a t'GI.Gio.Interfaces.ListModel.ListModel' that contains the pages of the leaflet.
-- 
-- 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 and change the visible
-- page.
leafletGetPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m Gtk.SelectionModel.SelectionModel
    -- ^ __Returns:__ a @GtkSelectionModel@ for the leaflet\'s children
leafletGetPages :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m SelectionModel
leafletGetPages a
self = IO SelectionModel -> m SelectionModel
forall a. IO a -> m a
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 Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SelectionModel
result <- Ptr Leaflet -> IO (Ptr SelectionModel)
adw_leaflet_get_pages Ptr Leaflet
self'
    Text -> Ptr SelectionModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"leafletGetPages" 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SelectionModel
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetPagesMethodInfo
instance (signature ~ (m Gtk.SelectionModel.SelectionModel), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetPagesMethodInfo a signature where
    overloadedMethod = leafletGetPages

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


#endif

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

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

-- | Gets the type of animation used for transitions between modes and children.
leafletGetTransitionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m Adw.Enums.LeafletTransitionType
    -- ^ __Returns:__ the current transition type of /@self@/
leafletGetTransitionType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m LeafletTransitionType
leafletGetTransitionType a
self = IO LeafletTransitionType -> m LeafletTransitionType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LeafletTransitionType -> m LeafletTransitionType)
-> IO LeafletTransitionType -> m LeafletTransitionType
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Leaflet -> IO CUInt
adw_leaflet_get_transition_type Ptr Leaflet
self'
    let result' :: LeafletTransitionType
result' = (Int -> LeafletTransitionType
forall a. Enum a => Int -> a
toEnum (Int -> LeafletTransitionType)
-> (CUInt -> Int) -> CUInt -> LeafletTransitionType
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
    LeafletTransitionType -> IO LeafletTransitionType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LeafletTransitionType
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetTransitionTypeMethodInfo
instance (signature ~ (m Adw.Enums.LeafletTransitionType), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetTransitionTypeMethodInfo a signature where
    overloadedMethod = leafletGetTransitionType

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


#endif

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

-- | Gets the widget currently visible when the leaflet is folded.
leafletGetVisibleChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the visible child
leafletGetVisibleChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m (Maybe Widget)
leafletGetVisibleChild a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr Leaflet -> IO (Ptr Widget)
adw_leaflet_get_visible_child Ptr Leaflet
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

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

foreign import ccall "adw_leaflet_get_visible_child_name" adw_leaflet_get_visible_child_name :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    IO CString

-- | Gets the name of the currently visible child widget.
leafletGetVisibleChildName ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the name of the visible child
leafletGetVisibleChildName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m (Maybe Text)
leafletGetVisibleChildName a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr Leaflet -> IO CString
adw_leaflet_get_visible_child_name Ptr Leaflet
self'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data LeafletGetVisibleChildNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletGetVisibleChildNameMethodInfo a signature where
    overloadedMethod = leafletGetVisibleChildName

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


#endif

-- method Leaflet::insert_child_after
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , 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 insert"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sibling"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the sibling after which to insert @child"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "LeafletPage" })
-- throws : False
-- Skip return : False

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

-- | Inserts /@child@/ in the position after /@sibling@/ in the list of children.
-- 
-- If /@sibling@/ is @NULL@, inserts /@child@/ at the first position.
leafletInsertChildAfter ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@self@/: a leaflet
    -> b
    -- ^ /@child@/: the widget to insert
    -> Maybe (c)
    -- ^ /@sibling@/: the sibling after which to insert /@child@/
    -> m Adw.LeafletPage.LeafletPage
    -- ^ __Returns:__ the [class/@leafletPage@/] for /@child@/
leafletInsertChildAfter :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsLeaflet a, IsWidget b, IsWidget c) =>
a -> b -> Maybe c -> m LeafletPage
leafletInsertChildAfter a
self b
child Maybe c
sibling = IO LeafletPage -> m LeafletPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LeafletPage -> m LeafletPage)
-> IO LeafletPage -> m LeafletPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
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 Widget
maybeSibling <- case Maybe c
sibling of
        Maybe c
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just c
jSibling -> do
            Ptr Widget
jSibling' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jSibling
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jSibling'
    Ptr LeafletPage
result <- Ptr Leaflet -> Ptr Widget -> Ptr Widget -> IO (Ptr LeafletPage)
adw_leaflet_insert_child_after Ptr Leaflet
self' Ptr Widget
child' Ptr Widget
maybeSibling
    Text -> Ptr LeafletPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"leafletInsertChildAfter" Ptr LeafletPage
result
    LeafletPage
result' <- ((ManagedPtr LeafletPage -> LeafletPage)
-> Ptr LeafletPage -> IO LeafletPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr LeafletPage -> LeafletPage
Adw.LeafletPage.LeafletPage) Ptr LeafletPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
sibling c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    LeafletPage -> IO LeafletPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LeafletPage
result'

#if defined(ENABLE_OVERLOADING)
data LeafletInsertChildAfterMethodInfo
instance (signature ~ (b -> Maybe (c) -> m Adw.LeafletPage.LeafletPage), MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) => O.OverloadedMethod LeafletInsertChildAfterMethodInfo a signature where
    overloadedMethod = leafletInsertChildAfter

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


#endif

-- method Leaflet::navigate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "direction"
--           , argType =
--               TInterface
--                 Name { namespace = "Adw" , name = "NavigationDirection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the direction" , 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_leaflet_navigate" adw_leaflet_navigate :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    CUInt ->                                -- direction : TInterface (Name {namespace = "Adw", name = "NavigationDirection"})
    IO CInt

-- | Navigates to the previous or next child.
-- 
-- The child must have the [property/@leafletPage@/:navigatable] property set to
-- @TRUE@, otherwise it will be skipped.
-- 
-- This will be the same child as returned by
-- [method/@leaflet@/.get_adjacent_child] or navigated to via swipe gestures.
leafletNavigate ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> Adw.Enums.NavigationDirection
    -- ^ /@direction@/: the direction
    -> m Bool
    -- ^ __Returns:__ whether the visible child was changed
leafletNavigate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> NavigationDirection -> m Bool
leafletNavigate a
self NavigationDirection
direction = IO Bool -> m Bool
forall a. IO a -> m a
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 Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let direction' :: CUInt
direction' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (NavigationDirection -> Int) -> NavigationDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NavigationDirection -> Int
forall a. Enum a => a -> Int
fromEnum) NavigationDirection
direction
    CInt
result <- Ptr Leaflet -> CUInt -> IO CInt
adw_leaflet_navigate Ptr Leaflet
self' CUInt
direction'
    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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data LeafletNavigateMethodInfo
instance (signature ~ (Adw.Enums.NavigationDirection -> m Bool), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletNavigateMethodInfo a signature where
    overloadedMethod = leafletNavigate

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


#endif

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

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

-- | Inserts /@child@/ at the first position in /@self@/.
leafletPrepend ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a leaflet
    -> b
    -- ^ /@child@/: the widget to prepend
    -> m Adw.LeafletPage.LeafletPage
    -- ^ __Returns:__ the [class/@leafletPage@/] for /@child@/
leafletPrepend :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsLeaflet a, IsWidget b) =>
a -> b -> m LeafletPage
leafletPrepend a
self b
child = IO LeafletPage -> m LeafletPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LeafletPage -> m LeafletPage)
-> IO LeafletPage -> m LeafletPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
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 LeafletPage
result <- Ptr Leaflet -> Ptr Widget -> IO (Ptr LeafletPage)
adw_leaflet_prepend Ptr Leaflet
self' Ptr Widget
child'
    Text -> Ptr LeafletPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"leafletPrepend" Ptr LeafletPage
result
    LeafletPage
result' <- ((ManagedPtr LeafletPage -> LeafletPage)
-> Ptr LeafletPage -> IO LeafletPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr LeafletPage -> LeafletPage
Adw.LeafletPage.LeafletPage) Ptr LeafletPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    LeafletPage -> IO LeafletPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LeafletPage
result'

#if defined(ENABLE_OVERLOADING)
data LeafletPrependMethodInfo
instance (signature ~ (b -> m Adw.LeafletPage.LeafletPage), MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b) => O.OverloadedMethod LeafletPrependMethodInfo a signature where
    overloadedMethod = leafletPrepend

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


#endif

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

-- | Removes a child widget from /@self@/.
leafletRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a leaflet
    -> b
    -- ^ /@child@/: the child to remove
    -> m ()
leafletRemove :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsLeaflet a, IsWidget b) =>
a -> b -> m ()
leafletRemove a
self b
child = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
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 Leaflet -> Ptr Widget -> IO ()
adw_leaflet_remove Ptr Leaflet
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method Leaflet::reorder_child_after
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , 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 move, must be a child of @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sibling"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the sibling to move @child after"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Moves /@child@/ to the position after /@sibling@/ in the list of children.
-- 
-- If /@sibling@/ is @NULL@, moves /@child@/ to the first position.
leafletReorderChildAfter ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@self@/: a leaflet
    -> b
    -- ^ /@child@/: the widget to move, must be a child of /@self@/
    -> Maybe (c)
    -- ^ /@sibling@/: the sibling to move /@child@/ after
    -> m ()
leafletReorderChildAfter :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsLeaflet a, IsWidget b, IsWidget c) =>
a -> b -> Maybe c -> m ()
leafletReorderChildAfter a
self b
child Maybe c
sibling = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
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 Widget
maybeSibling <- case Maybe c
sibling of
        Maybe c
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just c
jSibling -> do
            Ptr Widget
jSibling' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jSibling
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jSibling'
    Ptr Leaflet -> Ptr Widget -> Ptr Widget -> IO ()
adw_leaflet_reorder_child_after Ptr Leaflet
self' Ptr Widget
child' Ptr Widget
maybeSibling
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
sibling c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletReorderChildAfterMethodInfo
instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) => O.OverloadedMethod LeafletReorderChildAfterMethodInfo a signature where
    overloadedMethod = leafletReorderChildAfter

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


#endif

-- method Leaflet::set_can_navigate_back
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "can_navigate_back"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new 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_leaflet_set_can_navigate_back" adw_leaflet_set_can_navigate_back :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    CInt ->                                 -- can_navigate_back : TBasicType TBoolean
    IO ()

-- | Sets whether gestures and shortcuts for navigating backward are enabled.
-- 
-- The supported gestures are:
-- 
-- * One-finger swipe on touchscreens
-- * Horizontal scrolling on touchpads (usually two-finger swipe)
-- * Back\/forward mouse buttons
-- 
-- 
-- The keyboard back\/forward keys are also supported, as well as the
-- \<kbd>Alt\<\/kbd>+\<kbd>←\<\/kbd> shortcut for horizontal orientation, or
-- \<kbd>Alt\<\/kbd>+\<kbd>↑\<\/kbd> for vertical orientation.
-- 
-- If the orientation is horizontal, for right-to-left locales, gestures and
-- shortcuts are reversed.
-- 
-- Only children that have [property/@leafletPage@/:navigatable] set to @TRUE@ can
-- be navigated to.
leafletSetCanNavigateBack ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> Bool
    -- ^ /@canNavigateBack@/: the new value
    -> m ()
leafletSetCanNavigateBack :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Bool -> m ()
leafletSetCanNavigateBack a
self Bool
canNavigateBack = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let canNavigateBack' :: CInt
canNavigateBack' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
canNavigateBack
    Ptr Leaflet -> CInt -> IO ()
adw_leaflet_set_can_navigate_back Ptr Leaflet
self' CInt
canNavigateBack'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletSetCanNavigateBackMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletSetCanNavigateBackMethodInfo a signature where
    overloadedMethod = leafletSetCanNavigateBack

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


#endif

-- method Leaflet::set_can_navigate_forward
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "can_navigate_forward"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new 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_leaflet_set_can_navigate_forward" adw_leaflet_set_can_navigate_forward :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    CInt ->                                 -- can_navigate_forward : TBasicType TBoolean
    IO ()

-- | Sets whether gestures and shortcuts for navigating forward are enabled.
-- 
-- The supported gestures are:
-- 
-- * One-finger swipe on touchscreens
-- * Horizontal scrolling on touchpads (usually two-finger swipe)
-- * Back\/forward mouse buttons
-- 
-- 
-- The keyboard back\/forward keys are also supported, as well as the
-- \<kbd>Alt\<\/kbd>+\<kbd>→\<\/kbd> shortcut for horizontal orientation, or
-- \<kbd>Alt\<\/kbd>+\<kbd>↓\<\/kbd> for vertical orientation.
-- 
-- If the orientation is horizontal, for right-to-left locales, gestures and
-- shortcuts are reversed.
-- 
-- Only children that have [property/@leafletPage@/:navigatable] set to @TRUE@ can
-- be navigated to.
leafletSetCanNavigateForward ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> Bool
    -- ^ /@canNavigateForward@/: the new value
    -> m ()
leafletSetCanNavigateForward :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Bool -> m ()
leafletSetCanNavigateForward a
self Bool
canNavigateForward = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let canNavigateForward' :: CInt
canNavigateForward' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
canNavigateForward
    Ptr Leaflet -> CInt -> IO ()
adw_leaflet_set_can_navigate_forward Ptr Leaflet
self' CInt
canNavigateForward'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletSetCanNavigateForwardMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletSetCanNavigateForwardMethodInfo a signature where
    overloadedMethod = leafletSetCanNavigateForward

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


#endif

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

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

-- | Sets whether /@self@/ can unfold.
leafletSetCanUnfold ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> Bool
    -- ^ /@canUnfold@/: whether /@self@/ can unfold
    -> m ()
leafletSetCanUnfold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Bool -> m ()
leafletSetCanUnfold a
self Bool
canUnfold = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let canUnfold' :: CInt
canUnfold' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
canUnfold
    Ptr Leaflet -> CInt -> IO ()
adw_leaflet_set_can_unfold Ptr Leaflet
self' CInt
canUnfold'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletSetCanUnfoldMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletSetCanUnfoldMethodInfo a signature where
    overloadedMethod = leafletSetCanUnfold

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


#endif

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

foreign import ccall "adw_leaflet_set_child_transition_params" adw_leaflet_set_child_transition_params :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    Ptr Adw.SpringParams.SpringParams ->    -- params : TInterface (Name {namespace = "Adw", name = "SpringParams"})
    IO ()

-- | Sets the child transition spring parameters for /@self@/.
-- 
-- The default value is equivalent to:
-- 
-- 
-- === /c code/
-- >adw_spring_params_new (1, 0.5, 500)
leafletSetChildTransitionParams ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> Adw.SpringParams.SpringParams
    -- ^ /@params@/: the new parameters
    -> m ()
leafletSetChildTransitionParams :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> SpringParams -> m ()
leafletSetChildTransitionParams a
self SpringParams
params = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SpringParams
params' <- SpringParams -> IO (Ptr SpringParams)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SpringParams
params
    Ptr Leaflet -> Ptr SpringParams -> IO ()
adw_leaflet_set_child_transition_params Ptr Leaflet
self' Ptr SpringParams
params'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    SpringParams -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SpringParams
params
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletSetChildTransitionParamsMethodInfo
instance (signature ~ (Adw.SpringParams.SpringParams -> m ()), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletSetChildTransitionParamsMethodInfo a signature where
    overloadedMethod = leafletSetChildTransitionParams

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


#endif

-- method Leaflet::set_fold_threshold_policy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , 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_leaflet_set_fold_threshold_policy" adw_leaflet_set_fold_threshold_policy :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    CUInt ->                                -- policy : TInterface (Name {namespace = "Adw", name = "FoldThresholdPolicy"})
    IO ()

-- | Sets the fold threshold policy for /@self@/.
-- 
-- If set to @ADW_FOLD_THRESHOLD_POLICY_MINIMUM@, it will only fold when the
-- children cannot fit anymore. With @ADW_FOLD_THRESHOLD_POLICY_NATURAL@, it
-- will fold as soon as children don\'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 folding.
leafletSetFoldThresholdPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> Adw.Enums.FoldThresholdPolicy
    -- ^ /@policy@/: the policy to use
    -> m ()
leafletSetFoldThresholdPolicy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> FoldThresholdPolicy -> m ()
leafletSetFoldThresholdPolicy a
self FoldThresholdPolicy
policy = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
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 Leaflet -> CUInt -> IO ()
adw_leaflet_set_fold_threshold_policy Ptr Leaflet
self' CUInt
policy'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method Leaflet::set_homogeneous
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , 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 to make @self 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_leaflet_set_homogeneous" adw_leaflet_set_homogeneous :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    CInt ->                                 -- homogeneous : TBasicType TBoolean
    IO ()

-- | Sets /@self@/ to be homogeneous or not.
-- 
-- If set to @FALSE@, different children can have different size along the
-- opposite orientation.
leafletSetHomogeneous ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> Bool
    -- ^ /@homogeneous@/: whether to make /@self@/ homogeneous
    -> m ()
leafletSetHomogeneous :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Bool -> m ()
leafletSetHomogeneous a
self Bool
homogeneous = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
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
P.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
P.fromEnum) Bool
homogeneous
    Ptr Leaflet -> CInt -> IO ()
adw_leaflet_set_homogeneous Ptr Leaflet
self' CInt
homogeneous'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletSetHomogeneousMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletSetHomogeneousMethodInfo a signature where
    overloadedMethod = leafletSetHomogeneous

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


#endif

-- method Leaflet::set_mode_transition_duration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , 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_leaflet_set_mode_transition_duration" adw_leaflet_set_mode_transition_duration :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    Word32 ->                               -- duration : TBasicType TUInt
    IO ()

-- | Sets the mode transition animation duration for /@self@/.
leafletSetModeTransitionDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> Word32
    -- ^ /@duration@/: the new duration, in milliseconds
    -> m ()
leafletSetModeTransitionDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Word32 -> m ()
leafletSetModeTransitionDuration a
self Word32
duration = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Leaflet -> Word32 -> IO ()
adw_leaflet_set_mode_transition_duration Ptr Leaflet
self' Word32
duration
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletSetModeTransitionDurationMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletSetModeTransitionDurationMethodInfo a signature where
    overloadedMethod = leafletSetModeTransitionDuration

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


#endif

-- method Leaflet::set_transition_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "transition"
--           , argType =
--               TInterface
--                 Name { namespace = "Adw" , name = "LeafletTransitionType" }
--           , 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_leaflet_set_transition_type" adw_leaflet_set_transition_type :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    CUInt ->                                -- transition : TInterface (Name {namespace = "Adw", name = "LeafletTransitionType"})
    IO ()

-- | Sets the type of animation used for transitions between modes and children.
-- 
-- The transition type can be changed without problems at runtime, so it is
-- possible to change the animation based on the mode or child that is about to
-- become current.
leafletSetTransitionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> Adw.Enums.LeafletTransitionType
    -- ^ /@transition@/: the new transition type
    -> m ()
leafletSetTransitionType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> LeafletTransitionType -> m ()
leafletSetTransitionType a
self LeafletTransitionType
transition = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
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)
-> (LeafletTransitionType -> Int) -> LeafletTransitionType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LeafletTransitionType -> Int
forall a. Enum a => a -> Int
fromEnum) LeafletTransitionType
transition
    Ptr Leaflet -> CUInt -> IO ()
adw_leaflet_set_transition_type Ptr Leaflet
self' CUInt
transition'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletSetTransitionTypeMethodInfo
instance (signature ~ (Adw.Enums.LeafletTransitionType -> m ()), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletSetTransitionTypeMethodInfo a signature where
    overloadedMethod = leafletSetTransitionType

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


#endif

-- method Leaflet::set_visible_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "visible_child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new 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_leaflet_set_visible_child" adw_leaflet_set_visible_child :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    Ptr Gtk.Widget.Widget ->                -- visible_child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the widget currently visible when the leaflet is folded.
-- 
-- The transition is determined by [property/@leaflet@/:transition-type] and
-- [property/@leaflet@/:child-transition-params]. The transition can be cancelled
-- by the user, in which case visible child will change back to the previously
-- visible child.
leafletSetVisibleChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a leaflet
    -> b
    -- ^ /@visibleChild@/: the new child
    -> m ()
leafletSetVisibleChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsLeaflet a, IsWidget b) =>
a -> b -> m ()
leafletSetVisibleChild a
self b
visibleChild = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
visibleChild' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
visibleChild
    Ptr Leaflet -> Ptr Widget -> IO ()
adw_leaflet_set_visible_child Ptr Leaflet
self' Ptr Widget
visibleChild'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
visibleChild
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method Leaflet::set_visible_child_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a leaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of a 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_leaflet_set_visible_child_name" adw_leaflet_set_visible_child_name :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Adw", name = "Leaflet"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Makes the child with the name /@name@/ visible.
-- 
-- See [property/@leaflet@/:visible-child].
leafletSetVisibleChildName ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a leaflet
    -> T.Text
    -- ^ /@name@/: the name of a child
    -> m ()
leafletSetVisibleChildName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Text -> m ()
leafletSetVisibleChildName a
self Text
name = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Leaflet -> CString -> IO ()
adw_leaflet_set_visible_child_name Ptr Leaflet
self' CString
name'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletSetVisibleChildNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsLeaflet a) => O.OverloadedMethod LeafletSetVisibleChildNameMethodInfo a signature where
    overloadedMethod = leafletSetVisibleChildName

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


#endif