{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Handy.Objects.Leaflet
    ( 

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


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [add]("GI.Gtk.Objects.Container#g:method:add"), [addAccelerator]("GI.Gtk.Objects.Widget#g:method:addAccelerator"), [addChild]("GI.Gtk.Interfaces.Buildable#g:method:addChild"), [addDeviceEvents]("GI.Gtk.Objects.Widget#g:method:addDeviceEvents"), [addEvents]("GI.Gtk.Objects.Widget#g:method:addEvents"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [canActivateAccel]("GI.Gtk.Objects.Widget#g:method:canActivateAccel"), [checkResize]("GI.Gtk.Objects.Container#g:method:checkResize"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [childGetProperty]("GI.Gtk.Objects.Container#g:method:childGetProperty"), [childNotify]("GI.Gtk.Objects.Container#g:method:childNotify"), [childNotifyByPspec]("GI.Gtk.Objects.Container#g:method:childNotifyByPspec"), [childSetProperty]("GI.Gtk.Objects.Container#g:method:childSetProperty"), [childType]("GI.Gtk.Objects.Container#g:method:childType"), [classPath]("GI.Gtk.Objects.Widget#g:method:classPath"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [constructChild]("GI.Gtk.Interfaces.Buildable#g:method:constructChild"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [customFinished]("GI.Gtk.Interfaces.Buildable#g:method:customFinished"), [customTagEnd]("GI.Gtk.Interfaces.Buildable#g:method:customTagEnd"), [customTagStart]("GI.Gtk.Interfaces.Buildable#g:method:customTagStart"), [destroy]("GI.Gtk.Objects.Widget#g:method:destroy"), [destroyed]("GI.Gtk.Objects.Widget#g:method:destroyed"), [deviceIsShadowed]("GI.Gtk.Objects.Widget#g:method:deviceIsShadowed"), [dragBegin]("GI.Gtk.Objects.Widget#g:method:dragBegin"), [dragBeginWithCoordinates]("GI.Gtk.Objects.Widget#g:method:dragBeginWithCoordinates"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [dragDestAddImageTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddImageTargets"), [dragDestAddTextTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddTextTargets"), [dragDestAddUriTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddUriTargets"), [dragDestFindTarget]("GI.Gtk.Objects.Widget#g:method:dragDestFindTarget"), [dragDestGetTargetList]("GI.Gtk.Objects.Widget#g:method:dragDestGetTargetList"), [dragDestGetTrackMotion]("GI.Gtk.Objects.Widget#g:method:dragDestGetTrackMotion"), [dragDestSet]("GI.Gtk.Objects.Widget#g:method:dragDestSet"), [dragDestSetProxy]("GI.Gtk.Objects.Widget#g:method:dragDestSetProxy"), [dragDestSetTargetList]("GI.Gtk.Objects.Widget#g:method:dragDestSetTargetList"), [dragDestSetTrackMotion]("GI.Gtk.Objects.Widget#g:method:dragDestSetTrackMotion"), [dragDestUnset]("GI.Gtk.Objects.Widget#g:method:dragDestUnset"), [dragGetData]("GI.Gtk.Objects.Widget#g:method:dragGetData"), [dragHighlight]("GI.Gtk.Objects.Widget#g:method:dragHighlight"), [dragSourceAddImageTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddImageTargets"), [dragSourceAddTextTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddTextTargets"), [dragSourceAddUriTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddUriTargets"), [dragSourceGetTargetList]("GI.Gtk.Objects.Widget#g:method:dragSourceGetTargetList"), [dragSourceSet]("GI.Gtk.Objects.Widget#g:method:dragSourceSet"), [dragSourceSetIconGicon]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconGicon"), [dragSourceSetIconName]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconName"), [dragSourceSetIconPixbuf]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconPixbuf"), [dragSourceSetIconStock]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconStock"), [dragSourceSetTargetList]("GI.Gtk.Objects.Widget#g:method:dragSourceSetTargetList"), [dragSourceUnset]("GI.Gtk.Objects.Widget#g:method:dragSourceUnset"), [dragUnhighlight]("GI.Gtk.Objects.Widget#g:method:dragUnhighlight"), [draw]("GI.Gtk.Objects.Widget#g:method:draw"), [emitChildSwitched]("GI.Handy.Interfaces.Swipeable#g:method:emitChildSwitched"), [ensureStyle]("GI.Gtk.Objects.Widget#g:method:ensureStyle"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [event]("GI.Gtk.Objects.Widget#g:method:event"), [forall]("GI.Gtk.Objects.Container#g:method:forall"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.Gtk.Objects.Container#g:method:foreach"), [freezeChildNotify]("GI.Gtk.Objects.Widget#g:method:freezeChildNotify"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabAdd]("GI.Gtk.Objects.Widget#g:method:grabAdd"), [grabDefault]("GI.Gtk.Objects.Widget#g:method:grabDefault"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [grabRemove]("GI.Gtk.Objects.Widget#g:method:grabRemove"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasGrab]("GI.Gtk.Objects.Widget#g:method:hasGrab"), [hasRcStyle]("GI.Gtk.Objects.Widget#g:method:hasRcStyle"), [hasScreen]("GI.Gtk.Objects.Widget#g:method:hasScreen"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [hideOnDelete]("GI.Gtk.Objects.Widget#g:method:hideOnDelete"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [inputShapeCombineRegion]("GI.Gtk.Objects.Widget#g:method:inputShapeCombineRegion"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertChildAfter]("GI.Handy.Objects.Leaflet#g:method:insertChildAfter"), [intersect]("GI.Gtk.Objects.Widget#g:method:intersect"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isComposited]("GI.Gtk.Objects.Widget#g:method:isComposited"), [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"), [isToplevel]("GI.Gtk.Objects.Widget#g:method:isToplevel"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listAccelClosures]("GI.Gtk.Objects.Widget#g:method:listAccelClosures"), [listActionPrefixes]("GI.Gtk.Objects.Widget#g:method:listActionPrefixes"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [modifyBase]("GI.Gtk.Objects.Widget#g:method:modifyBase"), [modifyBg]("GI.Gtk.Objects.Widget#g:method:modifyBg"), [modifyCursor]("GI.Gtk.Objects.Widget#g:method:modifyCursor"), [modifyFg]("GI.Gtk.Objects.Widget#g:method:modifyFg"), [modifyFont]("GI.Gtk.Objects.Widget#g:method:modifyFont"), [modifyStyle]("GI.Gtk.Objects.Widget#g:method:modifyStyle"), [modifyText]("GI.Gtk.Objects.Widget#g:method:modifyText"), [navigate]("GI.Handy.Objects.Leaflet#g:method:navigate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [overrideBackgroundColor]("GI.Gtk.Objects.Widget#g:method:overrideBackgroundColor"), [overrideColor]("GI.Gtk.Objects.Widget#g:method:overrideColor"), [overrideCursor]("GI.Gtk.Objects.Widget#g:method:overrideCursor"), [overrideFont]("GI.Gtk.Objects.Widget#g:method:overrideFont"), [overrideSymbolicColor]("GI.Gtk.Objects.Widget#g:method:overrideSymbolicColor"), [parserFinished]("GI.Gtk.Interfaces.Buildable#g:method:parserFinished"), [path]("GI.Gtk.Objects.Widget#g:method:path"), [prepend]("GI.Handy.Objects.Leaflet#g:method:prepend"), [propagateDraw]("GI.Gtk.Objects.Container#g:method:propagateDraw"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueComputeExpand]("GI.Gtk.Objects.Widget#g:method:queueComputeExpand"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueDrawArea]("GI.Gtk.Objects.Widget#g:method:queueDrawArea"), [queueDrawRegion]("GI.Gtk.Objects.Widget#g:method:queueDrawRegion"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [queueResizeNoRedraw]("GI.Gtk.Objects.Widget#g:method:queueResizeNoRedraw"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [regionIntersect]("GI.Gtk.Objects.Widget#g:method:regionIntersect"), [registerWindow]("GI.Gtk.Objects.Widget#g:method:registerWindow"), [remove]("GI.Gtk.Objects.Container#g:method:remove"), [removeAccelerator]("GI.Gtk.Objects.Widget#g:method:removeAccelerator"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [renderIcon]("GI.Gtk.Objects.Widget#g:method:renderIcon"), [renderIconPixbuf]("GI.Gtk.Objects.Widget#g:method:renderIconPixbuf"), [reorderChildAfter]("GI.Handy.Objects.Leaflet#g:method:reorderChildAfter"), [reparent]("GI.Gtk.Objects.Widget#g:method:reparent"), [resetRcStyles]("GI.Gtk.Objects.Widget#g:method:resetRcStyles"), [resetStyle]("GI.Gtk.Objects.Widget#g:method:resetStyle"), [resizeChildren]("GI.Gtk.Objects.Container#g:method:resizeChildren"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [sendExpose]("GI.Gtk.Objects.Widget#g:method:sendExpose"), [sendFocusChange]("GI.Gtk.Objects.Widget#g:method:sendFocusChange"), [shapeCombineRegion]("GI.Gtk.Objects.Widget#g:method:shapeCombineRegion"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [showAll]("GI.Gtk.Objects.Widget#g:method:showAll"), [showNow]("GI.Gtk.Objects.Widget#g:method:showNow"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [sizeAllocateWithBaseline]("GI.Gtk.Objects.Widget#g:method:sizeAllocateWithBaseline"), [sizeRequest]("GI.Gtk.Objects.Widget#g:method:sizeRequest"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [styleAttach]("GI.Gtk.Objects.Widget#g:method:styleAttach"), [styleGetProperty]("GI.Gtk.Objects.Widget#g:method:styleGetProperty"), [switchChild]("GI.Handy.Interfaces.Swipeable#g:method:switchChild"), [thawChildNotify]("GI.Gtk.Objects.Widget#g:method:thawChildNotify"), [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"), [unregisterWindow]("GI.Gtk.Objects.Widget#g:method:unregisterWindow"), [unsetFocusChain]("GI.Gtk.Objects.Container#g:method:unsetFocusChain"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessible]("GI.Gtk.Objects.Widget#g:method:getAccessible"), [getActionGroup]("GI.Gtk.Objects.Widget#g:method:getActionGroup"), [getAdjacentChild]("GI.Handy.Objects.Leaflet#g:method:getAdjacentChild"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedSize]("GI.Gtk.Objects.Widget#g:method:getAllocatedSize"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAppPaintable]("GI.Gtk.Objects.Widget#g:method:getAppPaintable"), [getBorderWidth]("GI.Gtk.Objects.Container#g:method:getBorderWidth"), [getCanDefault]("GI.Gtk.Objects.Widget#g:method:getCanDefault"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanSwipeBack]("GI.Handy.Objects.Leaflet#g:method:getCanSwipeBack"), [getCanSwipeForward]("GI.Handy.Objects.Leaflet#g:method:getCanSwipeForward"), [getCancelProgress]("GI.Handy.Interfaces.Swipeable#g:method:getCancelProgress"), [getChildByName]("GI.Handy.Objects.Leaflet#g:method:getChildByName"), [getChildRequisition]("GI.Gtk.Objects.Widget#g:method:getChildRequisition"), [getChildTransitionDuration]("GI.Handy.Objects.Leaflet#g:method:getChildTransitionDuration"), [getChildTransitionRunning]("GI.Handy.Objects.Leaflet#g:method:getChildTransitionRunning"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getChildren]("GI.Gtk.Objects.Container#g:method:getChildren"), [getClip]("GI.Gtk.Objects.Widget#g:method:getClip"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getCompositeName]("GI.Gtk.Objects.Widget#g:method:getCompositeName"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDeviceEnabled]("GI.Gtk.Objects.Widget#g:method:getDeviceEnabled"), [getDeviceEvents]("GI.Gtk.Objects.Widget#g:method:getDeviceEvents"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getDistance]("GI.Handy.Interfaces.Swipeable#g:method:getDistance"), [getDoubleBuffered]("GI.Gtk.Objects.Widget#g:method:getDoubleBuffered"), [getEvents]("GI.Gtk.Objects.Widget#g:method:getEvents"), [getFocusChain]("GI.Gtk.Objects.Container#g:method:getFocusChain"), [getFocusChild]("GI.Gtk.Objects.Container#g:method:getFocusChild"), [getFocusHadjustment]("GI.Gtk.Objects.Container#g:method:getFocusHadjustment"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusVadjustment]("GI.Gtk.Objects.Container#g:method:getFocusVadjustment"), [getFolded]("GI.Handy.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"), [getHasWindow]("GI.Gtk.Objects.Widget#g:method:getHasWindow"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getHomogeneous]("GI.Handy.Objects.Leaflet#g:method:getHomogeneous"), [getInternalChild]("GI.Gtk.Interfaces.Buildable#g:method:getInternalChild"), [getInterpolateSize]("GI.Handy.Objects.Leaflet#g:method:getInterpolateSize"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginLeft]("GI.Gtk.Objects.Widget#g:method:getMarginLeft"), [getMarginRight]("GI.Gtk.Objects.Widget#g:method:getMarginRight"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getModeTransitionDuration]("GI.Handy.Objects.Leaflet#g:method:getModeTransitionDuration"), [getModifierMask]("GI.Gtk.Objects.Widget#g:method:getModifierMask"), [getModifierStyle]("GI.Gtk.Objects.Widget#g:method:getModifierStyle"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNoShowAll]("GI.Gtk.Objects.Widget#g:method:getNoShowAll"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOrientation]("GI.Gtk.Interfaces.Orientable#g:method:getOrientation"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getParentWindow]("GI.Gtk.Objects.Widget#g:method:getParentWindow"), [getPath]("GI.Gtk.Objects.Widget#g:method:getPath"), [getPathForChild]("GI.Gtk.Objects.Container#g:method:getPathForChild"), [getPointer]("GI.Gtk.Objects.Widget#g:method:getPointer"), [getPreferredHeight]("GI.Gtk.Objects.Widget#g:method:getPreferredHeight"), [getPreferredHeightAndBaselineForWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredHeightAndBaselineForWidth"), [getPreferredHeightForWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredHeightForWidth"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPreferredWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredWidth"), [getPreferredWidthForHeight]("GI.Gtk.Objects.Widget#g:method:getPreferredWidthForHeight"), [getProgress]("GI.Handy.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"), [getRequisition]("GI.Gtk.Objects.Widget#g:method:getRequisition"), [getResizeMode]("GI.Gtk.Objects.Container#g:method:getResizeMode"), [getRootWindow]("GI.Gtk.Objects.Widget#g:method:getRootWindow"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getScreen]("GI.Gtk.Objects.Widget#g:method:getScreen"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getSnapPoints]("GI.Handy.Interfaces.Swipeable#g:method:getSnapPoints"), [getState]("GI.Gtk.Objects.Widget#g:method:getState"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyle]("GI.Gtk.Objects.Widget#g:method:getStyle"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:getSupportMultidevice"), [getSwipeArea]("GI.Handy.Interfaces.Swipeable#g:method:getSwipeArea"), [getSwipeTracker]("GI.Handy.Interfaces.Swipeable#g:method:getSwipeTracker"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTooltipWindow]("GI.Gtk.Objects.Widget#g:method:getTooltipWindow"), [getToplevel]("GI.Gtk.Objects.Widget#g:method:getToplevel"), [getTransitionType]("GI.Handy.Objects.Leaflet#g:method:getTransitionType"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getValignWithBaseline]("GI.Gtk.Objects.Widget#g:method:getValignWithBaseline"), [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.Handy.Objects.Leaflet#g:method:getVisibleChild"), [getVisibleChildName]("GI.Handy.Objects.Leaflet#g:method:getVisibleChildName"), [getVisual]("GI.Gtk.Objects.Widget#g:method:getVisual"), [getWindow]("GI.Gtk.Objects.Widget#g:method:getWindow").
-- 
-- ==== Setters
-- [setAccelPath]("GI.Gtk.Objects.Widget#g:method:setAccelPath"), [setAllocation]("GI.Gtk.Objects.Widget#g:method:setAllocation"), [setAppPaintable]("GI.Gtk.Objects.Widget#g:method:setAppPaintable"), [setBorderWidth]("GI.Gtk.Objects.Container#g:method:setBorderWidth"), [setBuildableProperty]("GI.Gtk.Interfaces.Buildable#g:method:setBuildableProperty"), [setCanDefault]("GI.Gtk.Objects.Widget#g:method:setCanDefault"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanSwipeBack]("GI.Handy.Objects.Leaflet#g:method:setCanSwipeBack"), [setCanSwipeForward]("GI.Handy.Objects.Leaflet#g:method:setCanSwipeForward"), [setChildTransitionDuration]("GI.Handy.Objects.Leaflet#g:method:setChildTransitionDuration"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setClip]("GI.Gtk.Objects.Widget#g:method:setClip"), [setCompositeName]("GI.Gtk.Objects.Widget#g:method:setCompositeName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDeviceEnabled]("GI.Gtk.Objects.Widget#g:method:setDeviceEnabled"), [setDeviceEvents]("GI.Gtk.Objects.Widget#g:method:setDeviceEvents"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setDoubleBuffered]("GI.Gtk.Objects.Widget#g:method:setDoubleBuffered"), [setEvents]("GI.Gtk.Objects.Widget#g:method:setEvents"), [setFocusChain]("GI.Gtk.Objects.Container#g:method:setFocusChain"), [setFocusChild]("GI.Gtk.Objects.Container#g:method:setFocusChild"), [setFocusHadjustment]("GI.Gtk.Objects.Container#g:method:setFocusHadjustment"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusVadjustment]("GI.Gtk.Objects.Container#g:method:setFocusVadjustment"), [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"), [setHasWindow]("GI.Gtk.Objects.Widget#g:method:setHasWindow"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHomogeneous]("GI.Handy.Objects.Leaflet#g:method:setHomogeneous"), [setInterpolateSize]("GI.Handy.Objects.Leaflet#g:method:setInterpolateSize"), [setMapped]("GI.Gtk.Objects.Widget#g:method:setMapped"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginLeft]("GI.Gtk.Objects.Widget#g:method:setMarginLeft"), [setMarginRight]("GI.Gtk.Objects.Widget#g:method:setMarginRight"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setModeTransitionDuration]("GI.Handy.Objects.Leaflet#g:method:setModeTransitionDuration"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNoShowAll]("GI.Gtk.Objects.Widget#g:method:setNoShowAll"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOrientation]("GI.Gtk.Interfaces.Orientable#g:method:setOrientation"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setParentWindow]("GI.Gtk.Objects.Widget#g:method:setParentWindow"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRealized]("GI.Gtk.Objects.Widget#g:method:setRealized"), [setReallocateRedraws]("GI.Gtk.Objects.Container#g:method:setReallocateRedraws"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setRedrawOnAllocate]("GI.Gtk.Objects.Widget#g:method:setRedrawOnAllocate"), [setResizeMode]("GI.Gtk.Objects.Container#g:method:setResizeMode"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setState]("GI.Gtk.Objects.Widget#g:method:setState"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setStyle]("GI.Gtk.Objects.Widget#g:method:setStyle"), [setSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:setSupportMultidevice"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTooltipWindow]("GI.Gtk.Objects.Widget#g:method:setTooltipWindow"), [setTransitionType]("GI.Handy.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.Handy.Objects.Leaflet#g:method:setVisibleChild"), [setVisibleChildName]("GI.Handy.Objects.Leaflet#g:method:setVisibleChildName"), [setVisual]("GI.Gtk.Objects.Widget#g:method:setVisual"), [setWindow]("GI.Gtk.Objects.Widget#g:method:setWindow").

#if defined(ENABLE_OVERLOADING)
    ResolveLeafletMethod                    ,
#endif

-- ** getAdjacentChild #method:getAdjacentChild#

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


-- ** getCanSwipeBack #method:getCanSwipeBack#

#if defined(ENABLE_OVERLOADING)
    LeafletGetCanSwipeBackMethodInfo        ,
#endif
    leafletGetCanSwipeBack                  ,


-- ** getCanSwipeForward #method:getCanSwipeForward#

#if defined(ENABLE_OVERLOADING)
    LeafletGetCanSwipeForwardMethodInfo     ,
#endif
    leafletGetCanSwipeForward               ,


-- ** getChildByName #method:getChildByName#

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


-- ** getChildTransitionDuration #method:getChildTransitionDuration#

#if defined(ENABLE_OVERLOADING)
    LeafletGetChildTransitionDurationMethodInfo,
#endif
    leafletGetChildTransitionDuration       ,


-- ** getChildTransitionRunning #method:getChildTransitionRunning#

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


-- ** getFolded #method:getFolded#

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


-- ** getHomogeneous #method:getHomogeneous#

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


-- ** getInterpolateSize #method:getInterpolateSize#

#if defined(ENABLE_OVERLOADING)
    LeafletGetInterpolateSizeMethodInfo     ,
#endif
    leafletGetInterpolateSize               ,


-- ** getModeTransitionDuration #method:getModeTransitionDuration#

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


-- ** 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                          ,


-- ** reorderChildAfter #method:reorderChildAfter#

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


-- ** setCanSwipeBack #method:setCanSwipeBack#

#if defined(ENABLE_OVERLOADING)
    LeafletSetCanSwipeBackMethodInfo        ,
#endif
    leafletSetCanSwipeBack                  ,


-- ** setCanSwipeForward #method:setCanSwipeForward#

#if defined(ENABLE_OVERLOADING)
    LeafletSetCanSwipeForwardMethodInfo     ,
#endif
    leafletSetCanSwipeForward               ,


-- ** setChildTransitionDuration #method:setChildTransitionDuration#

#if defined(ENABLE_OVERLOADING)
    LeafletSetChildTransitionDurationMethodInfo,
#endif
    leafletSetChildTransitionDuration       ,


-- ** setHomogeneous #method:setHomogeneous#

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


-- ** setInterpolateSize #method:setInterpolateSize#

#if defined(ENABLE_OVERLOADING)
    LeafletSetInterpolateSizeMethodInfo     ,
#endif
    leafletSetInterpolateSize               ,


-- ** 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


-- ** canSwipeBack #attr:canSwipeBack#
-- | Whether or not the leaflet allows switching to the previous child that has
-- \'navigatable\' child property set to 'P.True' via a swipe gesture.
-- 
-- /Since: 0.0.12/

#if defined(ENABLE_OVERLOADING)
    LeafletCanSwipeBackPropertyInfo         ,
#endif
    constructLeafletCanSwipeBack            ,
    getLeafletCanSwipeBack                  ,
#if defined(ENABLE_OVERLOADING)
    leafletCanSwipeBack                     ,
#endif
    setLeafletCanSwipeBack                  ,


-- ** canSwipeForward #attr:canSwipeForward#
-- | Whether or not the leaflet allows switching to the next child that has
-- \'navigatable\' child property set to 'P.True' via a swipe gesture.
-- 
-- /Since: 0.0.12/

#if defined(ENABLE_OVERLOADING)
    LeafletCanSwipeForwardPropertyInfo      ,
#endif
    constructLeafletCanSwipeForward         ,
    getLeafletCanSwipeForward               ,
#if defined(ENABLE_OVERLOADING)
    leafletCanSwipeForward                  ,
#endif
    setLeafletCanSwipeForward               ,


-- ** childTransitionDuration #attr:childTransitionDuration#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    LeafletChildTransitionDurationPropertyInfo,
#endif
    constructLeafletChildTransitionDuration ,
    getLeafletChildTransitionDuration       ,
#if defined(ENABLE_OVERLOADING)
    leafletChildTransitionDuration          ,
#endif
    setLeafletChildTransitionDuration       ,


-- ** childTransitionRunning #attr:childTransitionRunning#
-- | /No description available in the introspection data./

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


-- ** folded #attr:folded#
-- | 'P.True' if the leaflet is folded.
-- 
-- The leaflet will be folded if the size allocated to it is smaller than the
-- sum of the natural size of its children, it will be unfolded otherwise.

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


-- ** hhomogeneousFolded #attr:hhomogeneousFolded#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    LeafletHhomogeneousFoldedPropertyInfo   ,
#endif
    constructLeafletHhomogeneousFolded      ,
    getLeafletHhomogeneousFolded            ,
#if defined(ENABLE_OVERLOADING)
    leafletHhomogeneousFolded               ,
#endif
    setLeafletHhomogeneousFolded            ,


-- ** hhomogeneousUnfolded #attr:hhomogeneousUnfolded#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    LeafletHhomogeneousUnfoldedPropertyInfo ,
#endif
    constructLeafletHhomogeneousUnfolded    ,
    getLeafletHhomogeneousUnfolded          ,
#if defined(ENABLE_OVERLOADING)
    leafletHhomogeneousUnfolded             ,
#endif
    setLeafletHhomogeneousUnfolded          ,


-- ** interpolateSize #attr:interpolateSize#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    LeafletInterpolateSizePropertyInfo      ,
#endif
    constructLeafletInterpolateSize         ,
    getLeafletInterpolateSize               ,
#if defined(ENABLE_OVERLOADING)
    leafletInterpolateSize                  ,
#endif
    setLeafletInterpolateSize               ,


-- ** modeTransitionDuration #attr:modeTransitionDuration#
-- | /No description available in the introspection data./

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


-- ** transitionType #attr:transitionType#
-- | The type of animation that will be 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.
-- 
-- /Since: 0.0.12/

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


-- ** vhomogeneousFolded #attr:vhomogeneousFolded#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    LeafletVhomogeneousFoldedPropertyInfo   ,
#endif
    constructLeafletVhomogeneousFolded      ,
    getLeafletVhomogeneousFolded            ,
#if defined(ENABLE_OVERLOADING)
    leafletVhomogeneousFolded               ,
#endif
    setLeafletVhomogeneousFolded            ,


-- ** vhomogeneousUnfolded #attr:vhomogeneousUnfolded#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    LeafletVhomogeneousUnfoldedPropertyInfo ,
#endif
    constructLeafletVhomogeneousUnfolded    ,
    getLeafletVhomogeneousUnfolded          ,
#if defined(ENABLE_OVERLOADING)
    leafletVhomogeneousUnfolded             ,
#endif
    setLeafletVhomogeneousUnfolded          ,


-- ** visibleChild #attr:visibleChild#
-- | /No description available in the introspection data./

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


-- ** visibleChildName #attr:visibleChildName#
-- | /No description available in the introspection data./

#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.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

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

-- | 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
/= :: Leaflet -> Leaflet -> Bool
$c/= :: Leaflet -> Leaflet -> Bool
== :: Leaflet -> Leaflet -> Bool
$c== :: Leaflet -> Leaflet -> Bool
Eq)

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

foreign import ccall "hdy_leaflet_get_type"
    c_hdy_leaflet_get_type :: IO B.Types.GType

instance B.Types.TypedObject Leaflet where
    glibType :: IO GType
glibType = IO GType
c_hdy_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.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable, Gtk.Orientable.Orientable, Handy.Swipeable.Swipeable]

-- | 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 (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_hdy_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 (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 :: *) :: * where
    ResolveLeafletMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveLeafletMethod "add" o = Gtk.Container.ContainerAddMethodInfo
    ResolveLeafletMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
    ResolveLeafletMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveLeafletMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
    ResolveLeafletMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
    ResolveLeafletMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveLeafletMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveLeafletMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveLeafletMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveLeafletMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
    ResolveLeafletMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
    ResolveLeafletMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveLeafletMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
    ResolveLeafletMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
    ResolveLeafletMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
    ResolveLeafletMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
    ResolveLeafletMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
    ResolveLeafletMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
    ResolveLeafletMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveLeafletMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveLeafletMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveLeafletMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveLeafletMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveLeafletMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveLeafletMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveLeafletMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
    ResolveLeafletMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
    ResolveLeafletMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
    ResolveLeafletMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
    ResolveLeafletMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
    ResolveLeafletMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveLeafletMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
    ResolveLeafletMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
    ResolveLeafletMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
    ResolveLeafletMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
    ResolveLeafletMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
    ResolveLeafletMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
    ResolveLeafletMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
    ResolveLeafletMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
    ResolveLeafletMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
    ResolveLeafletMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
    ResolveLeafletMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
    ResolveLeafletMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
    ResolveLeafletMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
    ResolveLeafletMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
    ResolveLeafletMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
    ResolveLeafletMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
    ResolveLeafletMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
    ResolveLeafletMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
    ResolveLeafletMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
    ResolveLeafletMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
    ResolveLeafletMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
    ResolveLeafletMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
    ResolveLeafletMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
    ResolveLeafletMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
    ResolveLeafletMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
    ResolveLeafletMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
    ResolveLeafletMethod "emitChildSwitched" o = Handy.Swipeable.SwipeableEmitChildSwitchedMethodInfo
    ResolveLeafletMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
    ResolveLeafletMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveLeafletMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
    ResolveLeafletMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
    ResolveLeafletMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveLeafletMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
    ResolveLeafletMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
    ResolveLeafletMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveLeafletMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveLeafletMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
    ResolveLeafletMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
    ResolveLeafletMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveLeafletMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
    ResolveLeafletMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveLeafletMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveLeafletMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
    ResolveLeafletMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
    ResolveLeafletMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
    ResolveLeafletMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveLeafletMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveLeafletMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
    ResolveLeafletMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveLeafletMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveLeafletMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
    ResolveLeafletMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveLeafletMethod "insertChildAfter" o = LeafletInsertChildAfterMethodInfo
    ResolveLeafletMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
    ResolveLeafletMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveLeafletMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
    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 "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
    ResolveLeafletMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveLeafletMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveLeafletMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
    ResolveLeafletMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
    ResolveLeafletMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveLeafletMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveLeafletMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveLeafletMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
    ResolveLeafletMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
    ResolveLeafletMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
    ResolveLeafletMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
    ResolveLeafletMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
    ResolveLeafletMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
    ResolveLeafletMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
    ResolveLeafletMethod "navigate" o = LeafletNavigateMethodInfo
    ResolveLeafletMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveLeafletMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveLeafletMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
    ResolveLeafletMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
    ResolveLeafletMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
    ResolveLeafletMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
    ResolveLeafletMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
    ResolveLeafletMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveLeafletMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
    ResolveLeafletMethod "prepend" o = LeafletPrependMethodInfo
    ResolveLeafletMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
    ResolveLeafletMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveLeafletMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
    ResolveLeafletMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveLeafletMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
    ResolveLeafletMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
    ResolveLeafletMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveLeafletMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
    ResolveLeafletMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveLeafletMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveLeafletMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveLeafletMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
    ResolveLeafletMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
    ResolveLeafletMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
    ResolveLeafletMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
    ResolveLeafletMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveLeafletMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveLeafletMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
    ResolveLeafletMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
    ResolveLeafletMethod "reorderChildAfter" o = LeafletReorderChildAfterMethodInfo
    ResolveLeafletMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
    ResolveLeafletMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
    ResolveLeafletMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
    ResolveLeafletMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
    ResolveLeafletMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveLeafletMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
    ResolveLeafletMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
    ResolveLeafletMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
    ResolveLeafletMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveLeafletMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
    ResolveLeafletMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
    ResolveLeafletMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveLeafletMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
    ResolveLeafletMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
    ResolveLeafletMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveLeafletMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveLeafletMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
    ResolveLeafletMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
    ResolveLeafletMethod "switchChild" o = Handy.Swipeable.SwipeableSwitchChildMethodInfo
    ResolveLeafletMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
    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 "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
    ResolveLeafletMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
    ResolveLeafletMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveLeafletMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveLeafletMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
    ResolveLeafletMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
    ResolveLeafletMethod "getAdjacentChild" o = LeafletGetAdjacentChildMethodInfo
    ResolveLeafletMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveLeafletMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveLeafletMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
    ResolveLeafletMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveLeafletMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveLeafletMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveLeafletMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveLeafletMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
    ResolveLeafletMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveLeafletMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveLeafletMethod "getCanSwipeBack" o = LeafletGetCanSwipeBackMethodInfo
    ResolveLeafletMethod "getCanSwipeForward" o = LeafletGetCanSwipeForwardMethodInfo
    ResolveLeafletMethod "getCancelProgress" o = Handy.Swipeable.SwipeableGetCancelProgressMethodInfo
    ResolveLeafletMethod "getChildByName" o = LeafletGetChildByNameMethodInfo
    ResolveLeafletMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
    ResolveLeafletMethod "getChildTransitionDuration" o = LeafletGetChildTransitionDurationMethodInfo
    ResolveLeafletMethod "getChildTransitionRunning" o = LeafletGetChildTransitionRunningMethodInfo
    ResolveLeafletMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveLeafletMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
    ResolveLeafletMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
    ResolveLeafletMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveLeafletMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
    ResolveLeafletMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveLeafletMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
    ResolveLeafletMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
    ResolveLeafletMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveLeafletMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveLeafletMethod "getDistance" o = Handy.Swipeable.SwipeableGetDistanceMethodInfo
    ResolveLeafletMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
    ResolveLeafletMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
    ResolveLeafletMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
    ResolveLeafletMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
    ResolveLeafletMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
    ResolveLeafletMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveLeafletMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
    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 "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
    ResolveLeafletMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveLeafletMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveLeafletMethod "getHomogeneous" o = LeafletGetHomogeneousMethodInfo
    ResolveLeafletMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveLeafletMethod "getInterpolateSize" o = LeafletGetInterpolateSizeMethodInfo
    ResolveLeafletMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveLeafletMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveLeafletMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveLeafletMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
    ResolveLeafletMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
    ResolveLeafletMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveLeafletMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveLeafletMethod "getModeTransitionDuration" o = LeafletGetModeTransitionDurationMethodInfo
    ResolveLeafletMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
    ResolveLeafletMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
    ResolveLeafletMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveLeafletMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
    ResolveLeafletMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveLeafletMethod "getOrientation" o = Gtk.Orientable.OrientableGetOrientationMethodInfo
    ResolveLeafletMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveLeafletMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveLeafletMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
    ResolveLeafletMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
    ResolveLeafletMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
    ResolveLeafletMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
    ResolveLeafletMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
    ResolveLeafletMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveLeafletMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
    ResolveLeafletMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveLeafletMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
    ResolveLeafletMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
    ResolveLeafletMethod "getProgress" o = Handy.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 "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
    ResolveLeafletMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
    ResolveLeafletMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
    ResolveLeafletMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveLeafletMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
    ResolveLeafletMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveLeafletMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveLeafletMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveLeafletMethod "getSnapPoints" o = Handy.Swipeable.SwipeableGetSnapPointsMethodInfo
    ResolveLeafletMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
    ResolveLeafletMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveLeafletMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
    ResolveLeafletMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveLeafletMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
    ResolveLeafletMethod "getSwipeArea" o = Handy.Swipeable.SwipeableGetSwipeAreaMethodInfo
    ResolveLeafletMethod "getSwipeTracker" o = Handy.Swipeable.SwipeableGetSwipeTrackerMethodInfo
    ResolveLeafletMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveLeafletMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveLeafletMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveLeafletMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
    ResolveLeafletMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
    ResolveLeafletMethod "getTransitionType" o = LeafletGetTransitionTypeMethodInfo
    ResolveLeafletMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveLeafletMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
    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 "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
    ResolveLeafletMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
    ResolveLeafletMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
    ResolveLeafletMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
    ResolveLeafletMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveLeafletMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
    ResolveLeafletMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveLeafletMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveLeafletMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveLeafletMethod "setCanSwipeBack" o = LeafletSetCanSwipeBackMethodInfo
    ResolveLeafletMethod "setCanSwipeForward" o = LeafletSetCanSwipeForwardMethodInfo
    ResolveLeafletMethod "setChildTransitionDuration" o = LeafletSetChildTransitionDurationMethodInfo
    ResolveLeafletMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveLeafletMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
    ResolveLeafletMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
    ResolveLeafletMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveLeafletMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveLeafletMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
    ResolveLeafletMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
    ResolveLeafletMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveLeafletMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
    ResolveLeafletMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
    ResolveLeafletMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
    ResolveLeafletMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
    ResolveLeafletMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
    ResolveLeafletMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveLeafletMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
    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 "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
    ResolveLeafletMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveLeafletMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveLeafletMethod "setHomogeneous" o = LeafletSetHomogeneousMethodInfo
    ResolveLeafletMethod "setInterpolateSize" o = LeafletSetInterpolateSizeMethodInfo
    ResolveLeafletMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
    ResolveLeafletMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveLeafletMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveLeafletMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
    ResolveLeafletMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
    ResolveLeafletMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveLeafletMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveLeafletMethod "setModeTransitionDuration" o = LeafletSetModeTransitionDurationMethodInfo
    ResolveLeafletMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveLeafletMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
    ResolveLeafletMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveLeafletMethod "setOrientation" o = Gtk.Orientable.OrientableSetOrientationMethodInfo
    ResolveLeafletMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveLeafletMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
    ResolveLeafletMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveLeafletMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
    ResolveLeafletMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
    ResolveLeafletMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveLeafletMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
    ResolveLeafletMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
    ResolveLeafletMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveLeafletMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveLeafletMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
    ResolveLeafletMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveLeafletMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
    ResolveLeafletMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
    ResolveLeafletMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveLeafletMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveLeafletMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
    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 "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
    ResolveLeafletMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
    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-swipe-back"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@can-swipe-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 #canSwipeBack
-- @
getLeafletCanSwipeBack :: (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletCanSwipeBack :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletCanSwipeBack o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"can-swipe-back"

-- | Set the value of the “@can-swipe-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 [ #canSwipeBack 'Data.GI.Base.Attributes.:=' value ]
-- @
setLeafletCanSwipeBack :: (MonadIO m, IsLeaflet o) => o -> Bool -> m ()
setLeafletCanSwipeBack :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> Bool -> m ()
setLeafletCanSwipeBack o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"can-swipe-back" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data LeafletCanSwipeBackPropertyInfo
instance AttrInfo LeafletCanSwipeBackPropertyInfo where
    type AttrAllowedOps LeafletCanSwipeBackPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletCanSwipeBackPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletCanSwipeBackPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint LeafletCanSwipeBackPropertyInfo = (~) Bool
    type AttrTransferType LeafletCanSwipeBackPropertyInfo = Bool
    type AttrGetType LeafletCanSwipeBackPropertyInfo = Bool
    type AttrLabel LeafletCanSwipeBackPropertyInfo = "can-swipe-back"
    type AttrOrigin LeafletCanSwipeBackPropertyInfo = Leaflet
    attrGet = getLeafletCanSwipeBack
    attrSet = setLeafletCanSwipeBack
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletCanSwipeBack
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.canSwipeBack"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:canSwipeBack"
        })
#endif

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

-- | Get the value of the “@can-swipe-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 #canSwipeForward
-- @
getLeafletCanSwipeForward :: (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletCanSwipeForward :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletCanSwipeForward o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"can-swipe-forward"

-- | Set the value of the “@can-swipe-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 [ #canSwipeForward 'Data.GI.Base.Attributes.:=' value ]
-- @
setLeafletCanSwipeForward :: (MonadIO m, IsLeaflet o) => o -> Bool -> m ()
setLeafletCanSwipeForward :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> Bool -> m ()
setLeafletCanSwipeForward o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"can-swipe-forward" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data LeafletCanSwipeForwardPropertyInfo
instance AttrInfo LeafletCanSwipeForwardPropertyInfo where
    type AttrAllowedOps LeafletCanSwipeForwardPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletCanSwipeForwardPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletCanSwipeForwardPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint LeafletCanSwipeForwardPropertyInfo = (~) Bool
    type AttrTransferType LeafletCanSwipeForwardPropertyInfo = Bool
    type AttrGetType LeafletCanSwipeForwardPropertyInfo = Bool
    type AttrLabel LeafletCanSwipeForwardPropertyInfo = "can-swipe-forward"
    type AttrOrigin LeafletCanSwipeForwardPropertyInfo = Leaflet
    attrGet = getLeafletCanSwipeForward
    attrSet = setLeafletCanSwipeForward
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletCanSwipeForward
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.canSwipeForward"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:canSwipeForward"
        })
#endif

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

-- | Get the value of the “@child-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 #childTransitionDuration
-- @
getLeafletChildTransitionDuration :: (MonadIO m, IsLeaflet o) => o -> m Word32
getLeafletChildTransitionDuration :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Word32
getLeafletChildTransitionDuration o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"child-transition-duration"

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

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

#if defined(ENABLE_OVERLOADING)
data LeafletChildTransitionDurationPropertyInfo
instance AttrInfo LeafletChildTransitionDurationPropertyInfo where
    type AttrAllowedOps LeafletChildTransitionDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletChildTransitionDurationPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletChildTransitionDurationPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint LeafletChildTransitionDurationPropertyInfo = (~) Word32
    type AttrTransferType LeafletChildTransitionDurationPropertyInfo = Word32
    type AttrGetType LeafletChildTransitionDurationPropertyInfo = Word32
    type AttrLabel LeafletChildTransitionDurationPropertyInfo = "child-transition-duration"
    type AttrOrigin LeafletChildTransitionDurationPropertyInfo = Leaflet
    attrGet = getLeafletChildTransitionDuration
    attrSet = setLeafletChildTransitionDuration
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletChildTransitionDuration
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.childTransitionDuration"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:childTransitionDuration"
        })
#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 (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.Handy.Objects.Leaflet.childTransitionRunning"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:childTransitionRunning"
        })
#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 (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.Handy.Objects.Leaflet.folded"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:folded"
        })
#endif

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

-- | Get the value of the “@hhomogeneous-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 #hhomogeneousFolded
-- @
getLeafletHhomogeneousFolded :: (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletHhomogeneousFolded :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletHhomogeneousFolded o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"hhomogeneous-folded"

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

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

#if defined(ENABLE_OVERLOADING)
data LeafletHhomogeneousFoldedPropertyInfo
instance AttrInfo LeafletHhomogeneousFoldedPropertyInfo where
    type AttrAllowedOps LeafletHhomogeneousFoldedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletHhomogeneousFoldedPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletHhomogeneousFoldedPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint LeafletHhomogeneousFoldedPropertyInfo = (~) Bool
    type AttrTransferType LeafletHhomogeneousFoldedPropertyInfo = Bool
    type AttrGetType LeafletHhomogeneousFoldedPropertyInfo = Bool
    type AttrLabel LeafletHhomogeneousFoldedPropertyInfo = "hhomogeneous-folded"
    type AttrOrigin LeafletHhomogeneousFoldedPropertyInfo = Leaflet
    attrGet = getLeafletHhomogeneousFolded
    attrSet = setLeafletHhomogeneousFolded
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletHhomogeneousFolded
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.hhomogeneousFolded"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:hhomogeneousFolded"
        })
#endif

-- VVV Prop "hhomogeneous-unfolded"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

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

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

#if defined(ENABLE_OVERLOADING)
data LeafletHhomogeneousUnfoldedPropertyInfo
instance AttrInfo LeafletHhomogeneousUnfoldedPropertyInfo where
    type AttrAllowedOps LeafletHhomogeneousUnfoldedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletHhomogeneousUnfoldedPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletHhomogeneousUnfoldedPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint LeafletHhomogeneousUnfoldedPropertyInfo = (~) Bool
    type AttrTransferType LeafletHhomogeneousUnfoldedPropertyInfo = Bool
    type AttrGetType LeafletHhomogeneousUnfoldedPropertyInfo = Bool
    type AttrLabel LeafletHhomogeneousUnfoldedPropertyInfo = "hhomogeneous-unfolded"
    type AttrOrigin LeafletHhomogeneousUnfoldedPropertyInfo = Leaflet
    attrGet = getLeafletHhomogeneousUnfolded
    attrSet = setLeafletHhomogeneousUnfolded
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletHhomogeneousUnfolded
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.hhomogeneousUnfolded"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:hhomogeneousUnfolded"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data LeafletInterpolateSizePropertyInfo
instance AttrInfo LeafletInterpolateSizePropertyInfo where
    type AttrAllowedOps LeafletInterpolateSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletInterpolateSizePropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletInterpolateSizePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint LeafletInterpolateSizePropertyInfo = (~) Bool
    type AttrTransferType LeafletInterpolateSizePropertyInfo = Bool
    type AttrGetType LeafletInterpolateSizePropertyInfo = Bool
    type AttrLabel LeafletInterpolateSizePropertyInfo = "interpolate-size"
    type AttrOrigin LeafletInterpolateSizePropertyInfo = Leaflet
    attrGet = getLeafletInterpolateSize
    attrSet = setLeafletInterpolateSize
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletInterpolateSize
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.interpolateSize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:interpolateSize"
        })
#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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"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.Handy.Objects.Leaflet.modeTransitionDuration"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:modeTransitionDuration"
        })
#endif

-- VVV Prop "transition-type"
   -- Type: TInterface (Name {namespace = "Handy", 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 Handy.Enums.LeafletTransitionType
getLeafletTransitionType :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> m LeafletTransitionType
getLeafletTransitionType o
obj = IO LeafletTransitionType -> m LeafletTransitionType
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 -> Handy.Enums.LeafletTransitionType -> m ()
setLeafletTransitionType :: forall (m :: * -> *) o.
(MonadIO m, IsLeaflet o) =>
o -> LeafletTransitionType -> m ()
setLeafletTransitionType o
obj LeafletTransitionType
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> 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) => Handy.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 (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> 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 = (~) Handy.Enums.LeafletTransitionType
    type AttrTransferTypeConstraint LeafletTransitionTypePropertyInfo = (~) Handy.Enums.LeafletTransitionType
    type AttrTransferType LeafletTransitionTypePropertyInfo = Handy.Enums.LeafletTransitionType
    type AttrGetType LeafletTransitionTypePropertyInfo = Handy.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.Handy.Objects.Leaflet.transitionType"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:transitionType"
        })
#endif

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

-- | Get the value of the “@vhomogeneous-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 #vhomogeneousFolded
-- @
getLeafletVhomogeneousFolded :: (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletVhomogeneousFolded :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Bool
getLeafletVhomogeneousFolded o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"vhomogeneous-folded"

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

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

#if defined(ENABLE_OVERLOADING)
data LeafletVhomogeneousFoldedPropertyInfo
instance AttrInfo LeafletVhomogeneousFoldedPropertyInfo where
    type AttrAllowedOps LeafletVhomogeneousFoldedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletVhomogeneousFoldedPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletVhomogeneousFoldedPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint LeafletVhomogeneousFoldedPropertyInfo = (~) Bool
    type AttrTransferType LeafletVhomogeneousFoldedPropertyInfo = Bool
    type AttrGetType LeafletVhomogeneousFoldedPropertyInfo = Bool
    type AttrLabel LeafletVhomogeneousFoldedPropertyInfo = "vhomogeneous-folded"
    type AttrOrigin LeafletVhomogeneousFoldedPropertyInfo = Leaflet
    attrGet = getLeafletVhomogeneousFolded
    attrSet = setLeafletVhomogeneousFolded
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletVhomogeneousFolded
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.vhomogeneousFolded"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:vhomogeneousFolded"
        })
#endif

-- VVV Prop "vhomogeneous-unfolded"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

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

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

#if defined(ENABLE_OVERLOADING)
data LeafletVhomogeneousUnfoldedPropertyInfo
instance AttrInfo LeafletVhomogeneousUnfoldedPropertyInfo where
    type AttrAllowedOps LeafletVhomogeneousUnfoldedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint LeafletVhomogeneousUnfoldedPropertyInfo = IsLeaflet
    type AttrSetTypeConstraint LeafletVhomogeneousUnfoldedPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint LeafletVhomogeneousUnfoldedPropertyInfo = (~) Bool
    type AttrTransferType LeafletVhomogeneousUnfoldedPropertyInfo = Bool
    type AttrGetType LeafletVhomogeneousUnfoldedPropertyInfo = Bool
    type AttrLabel LeafletVhomogeneousUnfoldedPropertyInfo = "vhomogeneous-unfolded"
    type AttrOrigin LeafletVhomogeneousUnfoldedPropertyInfo = Leaflet
    attrGet = getLeafletVhomogeneousUnfolded
    attrSet = setLeafletVhomogeneousUnfolded
    attrTransfer _ v = do
        return v
    attrConstruct = constructLeafletVhomogeneousUnfolded
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.vhomogeneousUnfolded"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:vhomogeneousUnfolded"
        })
#endif

-- VVV Prop "visible-child"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,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 Gtk.Widget.Widget
getLeafletVisibleChild :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Widget
getLeafletVisibleChild o
obj = IO Widget -> m Widget
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Widget -> m Widget) -> IO Widget -> m Widget
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Widget) -> IO Widget
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getLeafletVisibleChild" (IO (Maybe Widget) -> IO Widget) -> IO (Maybe Widget) -> IO 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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> 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 = 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.Handy.Objects.Leaflet.visibleChild"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:visibleChild"
        })
#endif

-- VVV Prop "visible-child-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,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 T.Text
getLeafletVisibleChildName :: forall (m :: * -> *) o. (MonadIO m, IsLeaflet o) => o -> m Text
getLeafletVisibleChildName o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getLeafletVisibleChildName" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO 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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> 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 = 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.Handy.Objects.Leaflet.visibleChildName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#g:attr:visibleChildName"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Leaflet
type instance O.AttributeList Leaflet = LeafletAttributeList
type LeafletAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canSwipeBack", LeafletCanSwipeBackPropertyInfo), '("canSwipeForward", LeafletCanSwipeForwardPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("childTransitionDuration", LeafletChildTransitionDurationPropertyInfo), '("childTransitionRunning", LeafletChildTransitionRunningPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("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), '("hhomogeneousFolded", LeafletHhomogeneousFoldedPropertyInfo), '("hhomogeneousUnfolded", LeafletHhomogeneousUnfoldedPropertyInfo), '("interpolateSize", LeafletInterpolateSizePropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("modeTransitionDuration", LeafletModeTransitionDurationPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("orientation", Gtk.Orientable.OrientableOrientationPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("transitionType", LeafletTransitionTypePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("vhomogeneousFolded", LeafletVhomogeneousFoldedPropertyInfo), '("vhomogeneousUnfolded", LeafletVhomogeneousUnfoldedPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("visibleChild", LeafletVisibleChildPropertyInfo), '("visibleChildName", LeafletVisibleChildNamePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
leafletCanSwipeBack :: AttrLabelProxy "canSwipeBack"
leafletCanSwipeBack = AttrLabelProxy

leafletCanSwipeForward :: AttrLabelProxy "canSwipeForward"
leafletCanSwipeForward = AttrLabelProxy

leafletChildTransitionDuration :: AttrLabelProxy "childTransitionDuration"
leafletChildTransitionDuration = AttrLabelProxy

leafletChildTransitionRunning :: AttrLabelProxy "childTransitionRunning"
leafletChildTransitionRunning = AttrLabelProxy

leafletFolded :: AttrLabelProxy "folded"
leafletFolded = AttrLabelProxy

leafletHhomogeneousFolded :: AttrLabelProxy "hhomogeneousFolded"
leafletHhomogeneousFolded = AttrLabelProxy

leafletHhomogeneousUnfolded :: AttrLabelProxy "hhomogeneousUnfolded"
leafletHhomogeneousUnfolded = AttrLabelProxy

leafletInterpolateSize :: AttrLabelProxy "interpolateSize"
leafletInterpolateSize = AttrLabelProxy

leafletModeTransitionDuration :: AttrLabelProxy "modeTransitionDuration"
leafletModeTransitionDuration = AttrLabelProxy

leafletTransitionType :: AttrLabelProxy "transitionType"
leafletTransitionType = AttrLabelProxy

leafletVhomogeneousFolded :: AttrLabelProxy "vhomogeneousFolded"
leafletVhomogeneousFolded = AttrLabelProxy

leafletVhomogeneousUnfolded :: AttrLabelProxy "vhomogeneousUnfolded"
leafletVhomogeneousUnfolded = AttrLabelProxy

leafletVisibleChild :: AttrLabelProxy "visibleChild"
leafletVisibleChild = AttrLabelProxy

leafletVisibleChildName :: AttrLabelProxy "visibleChildName"
leafletVisibleChildName = AttrLabelProxy

#endif

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

#endif

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

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

-- | /No description available in the introspection data./
leafletNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Leaflet
leafletNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Leaflet
leafletNew  = IO Leaflet -> m Leaflet
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)
hdy_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 (m :: * -> *) a. Monad m => a -> m a
return Leaflet
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

-- | Gets the previous or next child that doesn\'t have \'navigatable\' child
-- property set to 'P.False', or 'P.Nothing' if it doesn\'t exist. This will be the same
-- widget 'GI.Handy.Objects.Leaflet.leafletNavigate' will navigate to.
-- 
-- /Since: 1.0/
leafletGetAdjacentChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> Handy.Enums.NavigationDirection
    -- ^ /@direction@/: the direction
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the previous or next child, or
    --   'P.Nothing' if it doesn\'t exist.
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 (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)
hdy_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 (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(ENABLE_OVERLOADING)
data LeafletGetAdjacentChildMethodInfo
instance (signature ~ (Handy.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.Handy.Objects.Leaflet.leafletGetAdjacentChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetAdjacentChild"
        })


#endif

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

-- | Returns whether the t'GI.Handy.Objects.Leaflet.Leaflet' allows swiping to the previous child.
-- 
-- /Since: 0.0.12/
leafletGetCanSwipeBack ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if back swipe is enabled.
leafletGetCanSwipeBack :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Bool
leafletGetCanSwipeBack a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
hdy_leaflet_get_can_swipe_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 (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

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

instance O.OverloadedMethodInfo LeafletGetCanSwipeBackMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.leafletGetCanSwipeBack",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetCanSwipeBack"
        })


#endif

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

-- | Returns whether the t'GI.Handy.Objects.Leaflet.Leaflet' allows swiping to the next child.
-- 
-- /Since: 0.0.12/
leafletGetCanSwipeForward ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if forward swipe is enabled.
leafletGetCanSwipeForward :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Bool
leafletGetCanSwipeForward a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
hdy_leaflet_get_can_swipe_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 (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

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

instance O.OverloadedMethodInfo LeafletGetCanSwipeForwardMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.leafletGetCanSwipeForward",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetCanSwipeForward"
        })


#endif

-- method Leaflet::get_child_by_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyLeaflet" , 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 "hdy_leaflet_get_child_by_name" hdy_leaflet_get_child_by_name :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr Gtk.Widget.Widget)

-- | Finds the child of /@self@/ with the name given as the argument. Returns 'P.Nothing'
-- if there is no child with this name.
-- 
-- /Since: 1.0/
leafletGetChildByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.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 (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)
hdy_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 (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 (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.Handy.Objects.Leaflet.leafletGetChildByName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetChildByName"
        })


#endif

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

-- | Returns the amount of time (in milliseconds) that
-- transitions between children in /@self@/ will take.
leafletGetChildTransitionDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> m Word32
    -- ^ __Returns:__ the child transition duration
leafletGetChildTransitionDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Word32
leafletGetChildTransitionDuration a
self = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
hdy_leaflet_get_child_transition_duration Ptr Leaflet
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

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

instance O.OverloadedMethodInfo LeafletGetChildTransitionDurationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.leafletGetChildTransitionDuration",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetChildTransitionDuration"
        })


#endif

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

-- | Returns whether /@self@/ is currently in a transition from one page to
-- another.
leafletGetChildTransitionRunning ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the transition is currently running, 'P.False' otherwise.
leafletGetChildTransitionRunning :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Bool
leafletGetChildTransitionRunning a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
hdy_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 (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.Handy.Objects.Leaflet.leafletGetChildTransitionRunning",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetChildTransitionRunning"
        })


#endif

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

-- | Gets whether /@self@/ is folded.
leafletGetFolded ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.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 (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
hdy_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 (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.Handy.Objects.Leaflet.leafletGetFolded",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetFolded"
        })


#endif

-- method Leaflet::get_homogeneous
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyLeaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "folded"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the fold" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "orientation"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Orientation" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the orientation" , 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 "hdy_leaflet_get_homogeneous" hdy_leaflet_get_homogeneous :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})
    CInt ->                                 -- folded : TBasicType TBoolean
    CUInt ->                                -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"})
    IO CInt

-- | Gets whether /@self@/ is homogeneous for the given fold and orientation.
-- See 'GI.Handy.Objects.Leaflet.leafletSetHomogeneous'.
leafletGetHomogeneous ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> Bool
    -- ^ /@folded@/: the fold
    -> Gtk.Enums.Orientation
    -- ^ /@orientation@/: the orientation
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ is homogeneous for the given fold and orientation.
leafletGetHomogeneous :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Bool -> Orientation -> m Bool
leafletGetHomogeneous a
self Bool
folded Orientation
orientation = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let folded' :: CInt
folded' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
folded
    let orientation' :: CUInt
orientation' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Orientation -> Int) -> Orientation -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Orientation -> Int
forall a. Enum a => a -> Int
fromEnum) Orientation
orientation
    CInt
result <- Ptr Leaflet -> CInt -> CUInt -> IO CInt
hdy_leaflet_get_homogeneous Ptr Leaflet
self' CInt
folded' CUInt
orientation'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetHomogeneousMethodInfo
instance (signature ~ (Bool -> Gtk.Enums.Orientation -> 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.Handy.Objects.Leaflet.leafletGetHomogeneous",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetHomogeneous"
        })


#endif

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

-- | Returns whether the t'GI.Handy.Objects.Leaflet.Leaflet' is set up to interpolate between
-- the sizes of children on page switch.
leafletGetInterpolateSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if child sizes are interpolated
leafletGetInterpolateSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Bool
leafletGetInterpolateSize a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
hdy_leaflet_get_interpolate_size 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 (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

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

instance O.OverloadedMethodInfo LeafletGetInterpolateSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.leafletGetInterpolateSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetInterpolateSize"
        })


#endif

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

-- | Returns the amount of time (in milliseconds) that
-- transitions between modes in /@self@/ will take.
leafletGetModeTransitionDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> m Word32
    -- ^ __Returns:__ the mode transition duration
leafletGetModeTransitionDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Word32
leafletGetModeTransitionDuration a
self = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
hdy_leaflet_get_mode_transition_duration Ptr Leaflet
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data 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.Handy.Objects.Leaflet.leafletGetModeTransitionDuration",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetModeTransitionDuration"
        })


#endif

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

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

-- | Gets the type of animation that will be used
-- for transitions between modes and children in /@self@/.
-- 
-- /Since: 0.0.12/
leafletGetTransitionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> m Handy.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 (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
hdy_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 (m :: * -> *) a. Monad m => a -> m a
return LeafletTransitionType
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetTransitionTypeMethodInfo
instance (signature ~ (m Handy.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.Handy.Objects.Leaflet.leafletGetTransitionType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetTransitionType"
        })


#endif

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

-- | Gets the visible child widget.
leafletGetVisibleChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> m Gtk.Widget.Widget
    -- ^ __Returns:__ the visible child widget
leafletGetVisibleChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Widget
leafletGetVisibleChild a
self = IO Widget -> m Widget
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Widget -> m Widget) -> IO Widget -> m 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)
hdy_leaflet_get_visible_child Ptr Leaflet
self'
    Text -> Ptr Widget -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"leafletGetVisibleChild" Ptr Widget
result
    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
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetVisibleChildMethodInfo
instance (signature ~ (m 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.Handy.Objects.Leaflet.leafletGetVisibleChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetVisibleChild"
        })


#endif

-- method Leaflet::get_visible_child_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyLeaflet" , 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 "hdy_leaflet_get_visible_child_name" hdy_leaflet_get_visible_child_name :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})
    IO CString

-- | Gets the name of the currently visible child widget.
leafletGetVisibleChildName ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> m T.Text
    -- ^ __Returns:__ the name of the visible child
leafletGetVisibleChildName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> m Text
leafletGetVisibleChildName a
self = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m 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
hdy_leaflet_get_visible_child_name Ptr Leaflet
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"leafletGetVisibleChildName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data LeafletGetVisibleChildNameMethodInfo
instance (signature ~ (m 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.Handy.Objects.Leaflet.leafletGetVisibleChildName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletGetVisibleChildName"
        })


#endif

-- method Leaflet::insert_child_after
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyLeaflet" , 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 #GtkWidget 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: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_leaflet_insert_child_after" hdy_leaflet_insert_child_after :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", 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 ()

-- | Inserts /@child@/ in the position after /@sibling@/ in the list of children.
-- If /@sibling@/ is 'P.Nothing', insert /@child@/ at the first position.
-- 
-- /Since: 1.2/
leafletInsertChildAfter ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> b
    -- ^ /@child@/: the t'GI.Gtk.Objects.Widget.Widget' to insert
    -> Maybe (c)
    -- ^ /@sibling@/: the sibling after which to insert /@child@/
    -> m ()
leafletInsertChildAfter :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsLeaflet a, IsWidget b, IsWidget c) =>
a -> b -> Maybe c -> m ()
leafletInsertChildAfter a
self b
child Maybe c
sibling = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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 (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jSibling'
    Ptr Leaflet -> Ptr Widget -> Ptr Widget -> IO ()
hdy_leaflet_insert_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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletInsertChildAfterMethodInfo
instance (signature ~ (b -> Maybe (c) -> m ()), 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.Handy.Objects.Leaflet.leafletInsertChildAfter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletInsertChildAfter"
        })


#endif

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

-- | Switches to the previous or next child that doesn\'t have \'navigatable\' child
-- property set to 'P.False', similar to performing a swipe gesture to go in
-- /@direction@/.
-- 
-- /Since: 1.0/
leafletNavigate ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> Handy.Enums.NavigationDirection
    -- ^ /@direction@/: the direction
    -> m Bool
    -- ^ __Returns:__ 'P.True' if visible child was changed, 'P.False' otherwise.
leafletNavigate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> NavigationDirection -> m Bool
leafletNavigate a
self NavigationDirection
direction = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
hdy_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 (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data LeafletNavigateMethodInfo
instance (signature ~ (Handy.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.Handy.Objects.Leaflet.leafletNavigate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletNavigate"
        })


#endif

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

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

-- | Inserts /@child@/ at the first position in /@self@/.
-- 
-- /Since: 1.2/
leafletPrepend ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> b
    -- ^ /@child@/: the t'GI.Gtk.Objects.Widget.Widget' to prepend
    -> m ()
leafletPrepend :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsLeaflet a, IsWidget b) =>
a -> b -> m ()
leafletPrepend a
self b
child = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 ()
hdy_leaflet_prepend 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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletPrependMethodInfo
instance (signature ~ (b -> m ()), 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.Handy.Objects.Leaflet.leafletPrepend",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletPrepend"
        })


#endif

-- method Leaflet::reorder_child_after
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyLeaflet" , 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 #GtkWidget 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, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_leaflet_reorder_child_after" hdy_leaflet_reorder_child_after :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", 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 'P.Nothing', move /@child@/ to the first position.
-- 
-- /Since: 1.2/
leafletReorderChildAfter ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> b
    -- ^ /@child@/: the t'GI.Gtk.Objects.Widget.Widget' to move, must be a child of /@self@/
    -> Maybe (c)
    -- ^ /@sibling@/: the sibling to move /@child@/ after, or 'P.Nothing'
    -> 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 (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 (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 (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jSibling'
    Ptr Leaflet -> Ptr Widget -> Ptr Widget -> IO ()
hdy_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 (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.Handy.Objects.Leaflet.leafletReorderChildAfter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletReorderChildAfter"
        })


#endif

-- method Leaflet::set_can_swipe_back
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyLeaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "can_swipe_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 "hdy_leaflet_set_can_swipe_back" hdy_leaflet_set_can_swipe_back :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})
    CInt ->                                 -- can_swipe_back : TBasicType TBoolean
    IO ()

-- | Sets whether or not /@self@/ allows switching to the previous child that has
-- \'navigatable\' child property set to 'P.True' via a swipe gesture
-- 
-- /Since: 0.0.12/
leafletSetCanSwipeBack ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> Bool
    -- ^ /@canSwipeBack@/: the new value
    -> m ()
leafletSetCanSwipeBack :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Bool -> m ()
leafletSetCanSwipeBack a
self Bool
canSwipeBack = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let canSwipeBack' :: CInt
canSwipeBack' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
canSwipeBack
    Ptr Leaflet -> CInt -> IO ()
hdy_leaflet_set_can_swipe_back Ptr Leaflet
self' CInt
canSwipeBack'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo LeafletSetCanSwipeBackMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.leafletSetCanSwipeBack",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletSetCanSwipeBack"
        })


#endif

-- method Leaflet::set_can_swipe_forward
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyLeaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "can_swipe_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 "hdy_leaflet_set_can_swipe_forward" hdy_leaflet_set_can_swipe_forward :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})
    CInt ->                                 -- can_swipe_forward : TBasicType TBoolean
    IO ()

-- | Sets whether or not /@self@/ allows switching to the next child that has
-- \'navigatable\' child property set to 'P.True' via a swipe gesture.
-- 
-- /Since: 0.0.12/
leafletSetCanSwipeForward ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> Bool
    -- ^ /@canSwipeForward@/: the new value
    -> m ()
leafletSetCanSwipeForward :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Bool -> m ()
leafletSetCanSwipeForward a
self Bool
canSwipeForward = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let canSwipeForward' :: CInt
canSwipeForward' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
canSwipeForward
    Ptr Leaflet -> CInt -> IO ()
hdy_leaflet_set_can_swipe_forward Ptr Leaflet
self' CInt
canSwipeForward'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo LeafletSetCanSwipeForwardMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.leafletSetCanSwipeForward",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletSetCanSwipeForward"
        })


#endif

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

-- | Sets the duration that transitions between children in /@self@/
-- will take.
leafletSetChildTransitionDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> Word32
    -- ^ /@duration@/: the new duration, in milliseconds
    -> m ()
leafletSetChildTransitionDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Word32 -> m ()
leafletSetChildTransitionDuration a
self Word32
duration = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Leaflet -> Word32 -> IO ()
hdy_leaflet_set_child_transition_duration Ptr Leaflet
self' Word32
duration
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo LeafletSetChildTransitionDurationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.leafletSetChildTransitionDuration",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletSetChildTransitionDuration"
        })


#endif

-- method Leaflet::set_homogeneous
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyLeaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "folded"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the fold" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "orientation"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Orientation" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the orientation" , 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 "%TRUE 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 "hdy_leaflet_set_homogeneous" hdy_leaflet_set_homogeneous :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})
    CInt ->                                 -- folded : TBasicType TBoolean
    CUInt ->                                -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"})
    CInt ->                                 -- homogeneous : TBasicType TBoolean
    IO ()

-- | Sets the t'GI.Handy.Objects.Leaflet.Leaflet' to be homogeneous or not for the given fold and orientation.
-- If it is homogeneous, the t'GI.Handy.Objects.Leaflet.Leaflet' will request the same
-- width or height for all its children depending on the orientation.
-- If it isn\'t and it is folded, the leaflet may change width or height
-- when a different child becomes visible.
leafletSetHomogeneous ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> Bool
    -- ^ /@folded@/: the fold
    -> Gtk.Enums.Orientation
    -- ^ /@orientation@/: the orientation
    -> Bool
    -- ^ /@homogeneous@/: 'P.True' to make /@self@/ homogeneous
    -> m ()
leafletSetHomogeneous :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Bool -> Orientation -> Bool -> m ()
leafletSetHomogeneous a
self Bool
folded Orientation
orientation Bool
homogeneous = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let folded' :: CInt
folded' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
folded
    let orientation' :: CUInt
orientation' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Orientation -> Int) -> Orientation -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Orientation -> Int
forall a. Enum a => a -> Int
fromEnum) Orientation
orientation
    let homogeneous' :: CInt
homogeneous' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
homogeneous
    Ptr Leaflet -> CInt -> CUInt -> CInt -> IO ()
hdy_leaflet_set_homogeneous Ptr Leaflet
self' CInt
folded' CUInt
orientation' CInt
homogeneous'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletSetHomogeneousMethodInfo
instance (signature ~ (Bool -> Gtk.Enums.Orientation -> 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.Handy.Objects.Leaflet.leafletSetHomogeneous",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletSetHomogeneous"
        })


#endif

-- method Leaflet::set_interpolate_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyLeaflet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interpolate_size"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "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 "hdy_leaflet_set_interpolate_size" hdy_leaflet_set_interpolate_size :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})
    CInt ->                                 -- interpolate_size : TBasicType TBoolean
    IO ()

-- | Sets whether or not /@self@/ will interpolate its size when
-- changing the visible child. If the t'GI.Handy.Objects.Leaflet.Leaflet':@/interpolate-size/@
-- property is set to 'P.True', /@self@/ will interpolate its size between
-- the current one and the one it\'ll take after changing the
-- visible child, according to the set transition duration.
leafletSetInterpolateSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> Bool
    -- ^ /@interpolateSize@/: the new value
    -> m ()
leafletSetInterpolateSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLeaflet a) =>
a -> Bool -> m ()
leafletSetInterpolateSize a
self Bool
interpolateSize = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Leaflet
self' <- a -> IO (Ptr Leaflet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let interpolateSize' :: CInt
interpolateSize' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
interpolateSize
    Ptr Leaflet -> CInt -> IO ()
hdy_leaflet_set_interpolate_size Ptr Leaflet
self' CInt
interpolateSize'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo LeafletSetInterpolateSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Leaflet.leafletSetInterpolateSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletSetInterpolateSize"
        })


#endif

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

-- | Sets the duration that transitions between modes in /@self@/
-- will take.
leafletSetModeTransitionDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.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 (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 ()
hdy_leaflet_set_mode_transition_duration Ptr Leaflet
self' Word32
duration
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data 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.Handy.Objects.Leaflet.leafletSetModeTransitionDuration",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletSetModeTransitionDuration"
        })


#endif

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

-- | Sets the type of animation that will be used for transitions between modes
-- and children in /@self@/.
-- 
-- 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.
-- 
-- /Since: 0.0.12/
leafletSetTransitionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.Leaflet'
    -> Handy.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 (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 ()
hdy_leaflet_set_transition_type Ptr Leaflet
self' CUInt
transition'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LeafletSetTransitionTypeMethodInfo
instance (signature ~ (Handy.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.Handy.Objects.Leaflet.leafletSetTransitionType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletSetTransitionType"
        })


#endif

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

-- | Makes /@visibleChild@/ visible using a transition determined by
-- HdyLeaflet:transition-type and HdyLeaflet:child-transition-duration. 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 t'GI.Handy.Objects.Leaflet.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 (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 ()
hdy_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 (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.Handy.Objects.Leaflet.leafletSetVisibleChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletSetVisibleChild"
        })


#endif

-- method Leaflet::set_visible_child_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Leaflet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyLeaflet" , 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 "hdy_leaflet_set_visible_child_name" hdy_leaflet_set_visible_child_name :: 
    Ptr Leaflet ->                          -- self : TInterface (Name {namespace = "Handy", name = "Leaflet"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Makes the child with the name /@name@/ visible.
-- 
-- See 'GI.Handy.Objects.Leaflet.leafletSetVisibleChild' for more details.
leafletSetVisibleChildName ::
    (B.CallStack.HasCallStack, MonadIO m, IsLeaflet a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Leaflet.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 (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 ()
hdy_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 (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.Handy.Objects.Leaflet.leafletSetVisibleChildName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Leaflet.html#v:leafletSetVisibleChildName"
        })


#endif