{-# LANGUAGE ImplicitParams, RankNTypes, 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.Carousel
    ( 

-- * Exported types
    Carousel(..)                            ,
    IsCarousel                              ,
    toCarousel                              ,


 -- * 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"), [insert]("GI.Handy.Objects.Carousel#g:method:insert"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [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"), [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.Carousel#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"), [reorder]("GI.Handy.Objects.Carousel#g:method:reorder"), [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"), [scrollTo]("GI.Handy.Objects.Carousel#g:method:scrollTo"), [scrollToFull]("GI.Handy.Objects.Carousel#g:method:scrollToFull"), [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
-- [getAboveChild]("GI.Gtk.Objects.EventBox#g:method:getAboveChild"), [getAccessible]("GI.Gtk.Objects.Widget#g:method:getAccessible"), [getActionGroup]("GI.Gtk.Objects.Widget#g:method:getActionGroup"), [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"), [getAllowLongSwipes]("GI.Handy.Objects.Carousel#g:method:getAllowLongSwipes"), [getAllowMouseDrag]("GI.Handy.Objects.Carousel#g:method:getAllowMouseDrag"), [getAllowScrollWheel]("GI.Handy.Objects.Carousel#g:method:getAllowScrollWheel"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAnimationDuration]("GI.Handy.Objects.Carousel#g:method:getAnimationDuration"), [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"), [getCancelProgress]("GI.Handy.Interfaces.Swipeable#g:method:getCancelProgress"), [getChild]("GI.Gtk.Objects.Bin#g:method:getChild"), [getChildRequisition]("GI.Gtk.Objects.Widget#g:method:getChildRequisition"), [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"), [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"), [getInteractive]("GI.Handy.Objects.Carousel#g:method:getInteractive"), [getInternalChild]("GI.Gtk.Interfaces.Buildable#g:method:getInternalChild"), [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"), [getModifierMask]("GI.Gtk.Objects.Widget#g:method:getModifierMask"), [getModifierStyle]("GI.Gtk.Objects.Widget#g:method:getModifierStyle"), [getNPages]("GI.Handy.Objects.Carousel#g:method:getNPages"), [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"), [getPosition]("GI.Handy.Objects.Carousel#g:method:getPosition"), [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"), [getRevealDuration]("GI.Handy.Objects.Carousel#g:method:getRevealDuration"), [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"), [getSpacing]("GI.Handy.Objects.Carousel#g:method:getSpacing"), [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"), [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"), [getVisibleWindow]("GI.Gtk.Objects.EventBox#g:method:getVisibleWindow"), [getVisual]("GI.Gtk.Objects.Widget#g:method:getVisual"), [getWindow]("GI.Gtk.Objects.Widget#g:method:getWindow").
-- 
-- ==== Setters
-- [setAboveChild]("GI.Gtk.Objects.EventBox#g:method:setAboveChild"), [setAccelPath]("GI.Gtk.Objects.Widget#g:method:setAccelPath"), [setAllocation]("GI.Gtk.Objects.Widget#g:method:setAllocation"), [setAllowLongSwipes]("GI.Handy.Objects.Carousel#g:method:setAllowLongSwipes"), [setAllowMouseDrag]("GI.Handy.Objects.Carousel#g:method:setAllowMouseDrag"), [setAllowScrollWheel]("GI.Handy.Objects.Carousel#g:method:setAllowScrollWheel"), [setAnimationDuration]("GI.Handy.Objects.Carousel#g:method:setAnimationDuration"), [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"), [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"), [setInteractive]("GI.Handy.Objects.Carousel#g:method:setInteractive"), [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"), [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"), [setRevealDuration]("GI.Handy.Objects.Carousel#g:method:setRevealDuration"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setSpacing]("GI.Handy.Objects.Carousel#g:method:setSpacing"), [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"), [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"), [setVisibleWindow]("GI.Gtk.Objects.EventBox#g:method:setVisibleWindow"), [setVisual]("GI.Gtk.Objects.Widget#g:method:setVisual"), [setWindow]("GI.Gtk.Objects.Widget#g:method:setWindow").

#if defined(ENABLE_OVERLOADING)
    ResolveCarouselMethod                   ,
#endif

-- ** getAllowLongSwipes #method:getAllowLongSwipes#

#if defined(ENABLE_OVERLOADING)
    CarouselGetAllowLongSwipesMethodInfo    ,
#endif
    carouselGetAllowLongSwipes              ,


-- ** getAllowMouseDrag #method:getAllowMouseDrag#

#if defined(ENABLE_OVERLOADING)
    CarouselGetAllowMouseDragMethodInfo     ,
#endif
    carouselGetAllowMouseDrag               ,


-- ** getAllowScrollWheel #method:getAllowScrollWheel#

#if defined(ENABLE_OVERLOADING)
    CarouselGetAllowScrollWheelMethodInfo   ,
#endif
    carouselGetAllowScrollWheel             ,


-- ** getAnimationDuration #method:getAnimationDuration#

#if defined(ENABLE_OVERLOADING)
    CarouselGetAnimationDurationMethodInfo  ,
#endif
    carouselGetAnimationDuration            ,


-- ** getInteractive #method:getInteractive#

#if defined(ENABLE_OVERLOADING)
    CarouselGetInteractiveMethodInfo        ,
#endif
    carouselGetInteractive                  ,


-- ** getNPages #method:getNPages#

#if defined(ENABLE_OVERLOADING)
    CarouselGetNPagesMethodInfo             ,
#endif
    carouselGetNPages                       ,


-- ** getPosition #method:getPosition#

#if defined(ENABLE_OVERLOADING)
    CarouselGetPositionMethodInfo           ,
#endif
    carouselGetPosition                     ,


-- ** getRevealDuration #method:getRevealDuration#

#if defined(ENABLE_OVERLOADING)
    CarouselGetRevealDurationMethodInfo     ,
#endif
    carouselGetRevealDuration               ,


-- ** getSpacing #method:getSpacing#

#if defined(ENABLE_OVERLOADING)
    CarouselGetSpacingMethodInfo            ,
#endif
    carouselGetSpacing                      ,


-- ** insert #method:insert#

#if defined(ENABLE_OVERLOADING)
    CarouselInsertMethodInfo                ,
#endif
    carouselInsert                          ,


-- ** new #method:new#

    carouselNew                             ,


-- ** prepend #method:prepend#

#if defined(ENABLE_OVERLOADING)
    CarouselPrependMethodInfo               ,
#endif
    carouselPrepend                         ,


-- ** reorder #method:reorder#

#if defined(ENABLE_OVERLOADING)
    CarouselReorderMethodInfo               ,
#endif
    carouselReorder                         ,


-- ** scrollTo #method:scrollTo#

#if defined(ENABLE_OVERLOADING)
    CarouselScrollToMethodInfo              ,
#endif
    carouselScrollTo                        ,


-- ** scrollToFull #method:scrollToFull#

#if defined(ENABLE_OVERLOADING)
    CarouselScrollToFullMethodInfo          ,
#endif
    carouselScrollToFull                    ,


-- ** setAllowLongSwipes #method:setAllowLongSwipes#

#if defined(ENABLE_OVERLOADING)
    CarouselSetAllowLongSwipesMethodInfo    ,
#endif
    carouselSetAllowLongSwipes              ,


-- ** setAllowMouseDrag #method:setAllowMouseDrag#

#if defined(ENABLE_OVERLOADING)
    CarouselSetAllowMouseDragMethodInfo     ,
#endif
    carouselSetAllowMouseDrag               ,


-- ** setAllowScrollWheel #method:setAllowScrollWheel#

#if defined(ENABLE_OVERLOADING)
    CarouselSetAllowScrollWheelMethodInfo   ,
#endif
    carouselSetAllowScrollWheel             ,


-- ** setAnimationDuration #method:setAnimationDuration#

#if defined(ENABLE_OVERLOADING)
    CarouselSetAnimationDurationMethodInfo  ,
#endif
    carouselSetAnimationDuration            ,


-- ** setInteractive #method:setInteractive#

#if defined(ENABLE_OVERLOADING)
    CarouselSetInteractiveMethodInfo        ,
#endif
    carouselSetInteractive                  ,


-- ** setRevealDuration #method:setRevealDuration#

#if defined(ENABLE_OVERLOADING)
    CarouselSetRevealDurationMethodInfo     ,
#endif
    carouselSetRevealDuration               ,


-- ** setSpacing #method:setSpacing#

#if defined(ENABLE_OVERLOADING)
    CarouselSetSpacingMethodInfo            ,
#endif
    carouselSetSpacing                      ,




 -- * Properties


-- ** allowLongSwipes #attr:allowLongSwipes#
-- | Whether to allow swiping for more than one page at a time. If the value is
-- 'P.False', each swipe can only move to the adjacent pages.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    CarouselAllowLongSwipesPropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING)
    carouselAllowLongSwipes                 ,
#endif
    constructCarouselAllowLongSwipes        ,
    getCarouselAllowLongSwipes              ,
    setCarouselAllowLongSwipes              ,


-- ** allowMouseDrag #attr:allowMouseDrag#
-- | Sets whether the t'GI.Handy.Objects.Carousel.Carousel' can be dragged with mouse pointer. If the
-- value is 'P.False', dragging is only available on touch.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    CarouselAllowMouseDragPropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING)
    carouselAllowMouseDrag                  ,
#endif
    constructCarouselAllowMouseDrag         ,
    getCarouselAllowMouseDrag               ,
    setCarouselAllowMouseDrag               ,


-- ** allowScrollWheel #attr:allowScrollWheel#
-- | Whether the widget will respond to scroll wheel events. If the value is
-- 'P.False', wheel events will be ignored.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    CarouselAllowScrollWheelPropertyInfo    ,
#endif
#if defined(ENABLE_OVERLOADING)
    carouselAllowScrollWheel                ,
#endif
    constructCarouselAllowScrollWheel       ,
    getCarouselAllowScrollWheel             ,
    setCarouselAllowScrollWheel             ,


-- ** animationDuration #attr:animationDuration#
-- | Animation duration in milliseconds, used by 'GI.Handy.Objects.Carousel.carouselScrollTo'.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    CarouselAnimationDurationPropertyInfo   ,
#endif
#if defined(ENABLE_OVERLOADING)
    carouselAnimationDuration               ,
#endif
    constructCarouselAnimationDuration      ,
    getCarouselAnimationDuration            ,
    setCarouselAnimationDuration            ,


-- ** interactive #attr:interactive#
-- | Whether the carousel can be navigated. This can be used to temporarily
-- disable a t'GI.Handy.Objects.Carousel.Carousel' to only allow navigating it in a certain state.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    CarouselInteractivePropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    carouselInteractive                     ,
#endif
    constructCarouselInteractive            ,
    getCarouselInteractive                  ,
    setCarouselInteractive                  ,


-- ** nPages #attr:nPages#
-- | The number of pages in a t'GI.Handy.Objects.Carousel.Carousel'
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    CarouselNPagesPropertyInfo              ,
#endif
#if defined(ENABLE_OVERLOADING)
    carouselNPages                          ,
#endif
    getCarouselNPages                       ,


-- ** position #attr:position#
-- | Current scrolling position, unitless. 1 matches 1 page. Use
-- 'GI.Handy.Objects.Carousel.carouselScrollTo' for changing it.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    CarouselPositionPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    carouselPosition                        ,
#endif
    getCarouselPosition                     ,


-- ** revealDuration #attr:revealDuration#
-- | Page reveal duration in milliseconds.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    CarouselRevealDurationPropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING)
    carouselRevealDuration                  ,
#endif
    constructCarouselRevealDuration         ,
    getCarouselRevealDuration               ,
    setCarouselRevealDuration               ,


-- ** spacing #attr:spacing#
-- | Spacing between pages in pixels.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    CarouselSpacingPropertyInfo             ,
#endif
#if defined(ENABLE_OVERLOADING)
    carouselSpacing                         ,
#endif
    constructCarouselSpacing                ,
    getCarouselSpacing                      ,
    setCarouselSpacing                      ,




 -- * Signals


-- ** pageChanged #signal:pageChanged#

    CarouselPageChangedCallback             ,
#if defined(ENABLE_OVERLOADING)
    CarouselPageChangedSignalInfo           ,
#endif
    afterCarouselPageChanged                ,
    onCarouselPageChanged                   ,




    ) 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.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.Orientable as Gtk.Orientable
import qualified GI.Gtk.Objects.Bin as Gtk.Bin
import qualified GI.Gtk.Objects.Container as Gtk.Container
import qualified GI.Gtk.Objects.EventBox as Gtk.EventBox
import qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Handy.Interfaces.Swipeable as Handy.Swipeable

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

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

foreign import ccall "hdy_carousel_get_type"
    c_hdy_carousel_get_type :: IO B.Types.GType

instance B.Types.TypedObject Carousel where
    glibType :: IO GType
glibType = IO GType
c_hdy_carousel_get_type

instance B.Types.GObject Carousel

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

instance O.HasParentTypes Carousel
type instance O.ParentTypes Carousel = '[Gtk.EventBox.EventBox, Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable, Gtk.Orientable.Orientable, Handy.Swipeable.Swipeable]

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

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

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

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

#endif

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

#endif

-- signal Carousel::page-changed
-- | This signal is emitted after a page has been changed. This can be used to
-- implement \"infinite scrolling\" by connecting to this signal and amending
-- the pages.
-- 
-- /Since: 1.0/
type CarouselPageChangedCallback =
    Word32
    -- ^ /@index@/: Current page
    -> IO ()

type C_CarouselPageChangedCallback =
    Ptr Carousel ->                         -- object
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_CarouselPageChangedCallback`.
foreign import ccall "wrapper"
    mk_CarouselPageChangedCallback :: C_CarouselPageChangedCallback -> IO (FunPtr C_CarouselPageChangedCallback)

wrap_CarouselPageChangedCallback :: 
    GObject a => (a -> CarouselPageChangedCallback) ->
    C_CarouselPageChangedCallback
wrap_CarouselPageChangedCallback :: forall a.
GObject a =>
(a -> CarouselPageChangedCallback) -> C_CarouselPageChangedCallback
wrap_CarouselPageChangedCallback a -> CarouselPageChangedCallback
gi'cb Ptr Carousel
gi'selfPtr Word32
index Ptr ()
_ = do
    Ptr Carousel -> (Carousel -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Carousel
gi'selfPtr ((Carousel -> IO ()) -> IO ()) -> (Carousel -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Carousel
gi'self -> a -> CarouselPageChangedCallback
gi'cb (Carousel -> a
Coerce.coerce Carousel
gi'self)  Word32
index


-- | Connect a signal handler for the [pageChanged](#signal:pageChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' carousel #pageChanged callback
-- @
-- 
-- 
onCarouselPageChanged :: (IsCarousel a, MonadIO m) => a -> ((?self :: a) => CarouselPageChangedCallback) -> m SignalHandlerId
onCarouselPageChanged :: forall a (m :: * -> *).
(IsCarousel a, MonadIO m) =>
a
-> ((?self::a) => CarouselPageChangedCallback) -> m SignalHandlerId
onCarouselPageChanged a
obj (?self::a) => CarouselPageChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> CarouselPageChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => CarouselPageChangedCallback
CarouselPageChangedCallback
cb
    let wrapped' :: C_CarouselPageChangedCallback
wrapped' = (a -> CarouselPageChangedCallback) -> C_CarouselPageChangedCallback
forall a.
GObject a =>
(a -> CarouselPageChangedCallback) -> C_CarouselPageChangedCallback
wrap_CarouselPageChangedCallback a -> CarouselPageChangedCallback
wrapped
    FunPtr C_CarouselPageChangedCallback
wrapped'' <- C_CarouselPageChangedCallback
-> IO (FunPtr C_CarouselPageChangedCallback)
mk_CarouselPageChangedCallback C_CarouselPageChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_CarouselPageChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-changed" FunPtr C_CarouselPageChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pageChanged](#signal:pageChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' carousel #pageChanged callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterCarouselPageChanged :: (IsCarousel a, MonadIO m) => a -> ((?self :: a) => CarouselPageChangedCallback) -> m SignalHandlerId
afterCarouselPageChanged :: forall a (m :: * -> *).
(IsCarousel a, MonadIO m) =>
a
-> ((?self::a) => CarouselPageChangedCallback) -> m SignalHandlerId
afterCarouselPageChanged a
obj (?self::a) => CarouselPageChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> CarouselPageChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => CarouselPageChangedCallback
CarouselPageChangedCallback
cb
    let wrapped' :: C_CarouselPageChangedCallback
wrapped' = (a -> CarouselPageChangedCallback) -> C_CarouselPageChangedCallback
forall a.
GObject a =>
(a -> CarouselPageChangedCallback) -> C_CarouselPageChangedCallback
wrap_CarouselPageChangedCallback a -> CarouselPageChangedCallback
wrapped
    FunPtr C_CarouselPageChangedCallback
wrapped'' <- C_CarouselPageChangedCallback
-> IO (FunPtr C_CarouselPageChangedCallback)
mk_CarouselPageChangedCallback C_CarouselPageChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_CarouselPageChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-changed" FunPtr C_CarouselPageChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data CarouselPageChangedSignalInfo
instance SignalInfo CarouselPageChangedSignalInfo where
    type HaskellCallbackType CarouselPageChangedSignalInfo = CarouselPageChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_CarouselPageChangedCallback cb
        cb'' <- mk_CarouselPageChangedCallback cb'
        connectSignalFunPtr obj "page-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Carousel::page-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Carousel.html#g:signal:pageChanged"})

#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data CarouselAllowLongSwipesPropertyInfo
instance AttrInfo CarouselAllowLongSwipesPropertyInfo where
    type AttrAllowedOps CarouselAllowLongSwipesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CarouselAllowLongSwipesPropertyInfo = IsCarousel
    type AttrSetTypeConstraint CarouselAllowLongSwipesPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint CarouselAllowLongSwipesPropertyInfo = (~) Bool
    type AttrTransferType CarouselAllowLongSwipesPropertyInfo = Bool
    type AttrGetType CarouselAllowLongSwipesPropertyInfo = Bool
    type AttrLabel CarouselAllowLongSwipesPropertyInfo = "allow-long-swipes"
    type AttrOrigin CarouselAllowLongSwipesPropertyInfo = Carousel
    attrGet = getCarouselAllowLongSwipes
    attrSet = setCarouselAllowLongSwipes
    attrTransfer _ v = do
        return v
    attrConstruct = constructCarouselAllowLongSwipes
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Carousel.allowLongSwipes"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Carousel.html#g:attr:allowLongSwipes"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data CarouselAllowMouseDragPropertyInfo
instance AttrInfo CarouselAllowMouseDragPropertyInfo where
    type AttrAllowedOps CarouselAllowMouseDragPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CarouselAllowMouseDragPropertyInfo = IsCarousel
    type AttrSetTypeConstraint CarouselAllowMouseDragPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint CarouselAllowMouseDragPropertyInfo = (~) Bool
    type AttrTransferType CarouselAllowMouseDragPropertyInfo = Bool
    type AttrGetType CarouselAllowMouseDragPropertyInfo = Bool
    type AttrLabel CarouselAllowMouseDragPropertyInfo = "allow-mouse-drag"
    type AttrOrigin CarouselAllowMouseDragPropertyInfo = Carousel
    attrGet = getCarouselAllowMouseDrag
    attrSet = setCarouselAllowMouseDrag
    attrTransfer _ v = do
        return v
    attrConstruct = constructCarouselAllowMouseDrag
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Carousel.allowMouseDrag"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Carousel.html#g:attr:allowMouseDrag"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data CarouselAllowScrollWheelPropertyInfo
instance AttrInfo CarouselAllowScrollWheelPropertyInfo where
    type AttrAllowedOps CarouselAllowScrollWheelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CarouselAllowScrollWheelPropertyInfo = IsCarousel
    type AttrSetTypeConstraint CarouselAllowScrollWheelPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint CarouselAllowScrollWheelPropertyInfo = (~) Bool
    type AttrTransferType CarouselAllowScrollWheelPropertyInfo = Bool
    type AttrGetType CarouselAllowScrollWheelPropertyInfo = Bool
    type AttrLabel CarouselAllowScrollWheelPropertyInfo = "allow-scroll-wheel"
    type AttrOrigin CarouselAllowScrollWheelPropertyInfo = Carousel
    attrGet = getCarouselAllowScrollWheel
    attrSet = setCarouselAllowScrollWheel
    attrTransfer _ v = do
        return v
    attrConstruct = constructCarouselAllowScrollWheel
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Carousel.allowScrollWheel"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Carousel.html#g:attr:allowScrollWheel"
        })
#endif

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

-- | Get the value of the “@animation-duration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' carousel #animationDuration
-- @
getCarouselAnimationDuration :: (MonadIO m, IsCarousel o) => o -> m Word32
getCarouselAnimationDuration :: forall (m :: * -> *) o. (MonadIO m, IsCarousel o) => o -> m Word32
getCarouselAnimationDuration 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
"animation-duration"

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

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

#if defined(ENABLE_OVERLOADING)
data CarouselAnimationDurationPropertyInfo
instance AttrInfo CarouselAnimationDurationPropertyInfo where
    type AttrAllowedOps CarouselAnimationDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CarouselAnimationDurationPropertyInfo = IsCarousel
    type AttrSetTypeConstraint CarouselAnimationDurationPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint CarouselAnimationDurationPropertyInfo = (~) Word32
    type AttrTransferType CarouselAnimationDurationPropertyInfo = Word32
    type AttrGetType CarouselAnimationDurationPropertyInfo = Word32
    type AttrLabel CarouselAnimationDurationPropertyInfo = "animation-duration"
    type AttrOrigin CarouselAnimationDurationPropertyInfo = Carousel
    attrGet = getCarouselAnimationDuration
    attrSet = setCarouselAnimationDuration
    attrTransfer _ v = do
        return v
    attrConstruct = constructCarouselAnimationDuration
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Carousel.animationDuration"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Carousel.html#g:attr:animationDuration"
        })
#endif

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

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

-- | Set the value of the “@interactive@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' carousel [ #interactive 'Data.GI.Base.Attributes.:=' value ]
-- @
setCarouselInteractive :: (MonadIO m, IsCarousel o) => o -> Bool -> m ()
setCarouselInteractive :: forall (m :: * -> *) o.
(MonadIO m, IsCarousel o) =>
o -> Bool -> m ()
setCarouselInteractive 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
"interactive" Bool
val

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

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

-- VVV Prop "n-pages"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@n-pages@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' carousel #nPages
-- @
getCarouselNPages :: (MonadIO m, IsCarousel o) => o -> m Word32
getCarouselNPages :: forall (m :: * -> *) o. (MonadIO m, IsCarousel o) => o -> m Word32
getCarouselNPages 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
"n-pages"

#if defined(ENABLE_OVERLOADING)
data CarouselNPagesPropertyInfo
instance AttrInfo CarouselNPagesPropertyInfo where
    type AttrAllowedOps CarouselNPagesPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint CarouselNPagesPropertyInfo = IsCarousel
    type AttrSetTypeConstraint CarouselNPagesPropertyInfo = (~) ()
    type AttrTransferTypeConstraint CarouselNPagesPropertyInfo = (~) ()
    type AttrTransferType CarouselNPagesPropertyInfo = ()
    type AttrGetType CarouselNPagesPropertyInfo = Word32
    type AttrLabel CarouselNPagesPropertyInfo = "n-pages"
    type AttrOrigin CarouselNPagesPropertyInfo = Carousel
    attrGet = getCarouselNPages
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Carousel.nPages"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Carousel.html#g:attr:nPages"
        })
#endif

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

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

#if defined(ENABLE_OVERLOADING)
data CarouselPositionPropertyInfo
instance AttrInfo CarouselPositionPropertyInfo where
    type AttrAllowedOps CarouselPositionPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint CarouselPositionPropertyInfo = IsCarousel
    type AttrSetTypeConstraint CarouselPositionPropertyInfo = (~) ()
    type AttrTransferTypeConstraint CarouselPositionPropertyInfo = (~) ()
    type AttrTransferType CarouselPositionPropertyInfo = ()
    type AttrGetType CarouselPositionPropertyInfo = Double
    type AttrLabel CarouselPositionPropertyInfo = "position"
    type AttrOrigin CarouselPositionPropertyInfo = Carousel
    attrGet = getCarouselPosition
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Carousel.position"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Carousel.html#g:attr:position"
        })
#endif

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

-- | Get the value of the “@reveal-duration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' carousel #revealDuration
-- @
getCarouselRevealDuration :: (MonadIO m, IsCarousel o) => o -> m Word32
getCarouselRevealDuration :: forall (m :: * -> *) o. (MonadIO m, IsCarousel o) => o -> m Word32
getCarouselRevealDuration 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
"reveal-duration"

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

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

#if defined(ENABLE_OVERLOADING)
data CarouselRevealDurationPropertyInfo
instance AttrInfo CarouselRevealDurationPropertyInfo where
    type AttrAllowedOps CarouselRevealDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CarouselRevealDurationPropertyInfo = IsCarousel
    type AttrSetTypeConstraint CarouselRevealDurationPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint CarouselRevealDurationPropertyInfo = (~) Word32
    type AttrTransferType CarouselRevealDurationPropertyInfo = Word32
    type AttrGetType CarouselRevealDurationPropertyInfo = Word32
    type AttrLabel CarouselRevealDurationPropertyInfo = "reveal-duration"
    type AttrOrigin CarouselRevealDurationPropertyInfo = Carousel
    attrGet = getCarouselRevealDuration
    attrSet = setCarouselRevealDuration
    attrTransfer _ v = do
        return v
    attrConstruct = constructCarouselRevealDuration
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Carousel.revealDuration"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Carousel.html#g:attr:revealDuration"
        })
#endif

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

-- | Get the value of the “@spacing@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' carousel #spacing
-- @
getCarouselSpacing :: (MonadIO m, IsCarousel o) => o -> m Word32
getCarouselSpacing :: forall (m :: * -> *) o. (MonadIO m, IsCarousel o) => o -> m Word32
getCarouselSpacing 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
"spacing"

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

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

#if defined(ENABLE_OVERLOADING)
data CarouselSpacingPropertyInfo
instance AttrInfo CarouselSpacingPropertyInfo where
    type AttrAllowedOps CarouselSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CarouselSpacingPropertyInfo = IsCarousel
    type AttrSetTypeConstraint CarouselSpacingPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint CarouselSpacingPropertyInfo = (~) Word32
    type AttrTransferType CarouselSpacingPropertyInfo = Word32
    type AttrGetType CarouselSpacingPropertyInfo = Word32
    type AttrLabel CarouselSpacingPropertyInfo = "spacing"
    type AttrOrigin CarouselSpacingPropertyInfo = Carousel
    attrGet = getCarouselSpacing
    attrSet = setCarouselSpacing
    attrTransfer _ v = do
        return v
    attrConstruct = constructCarouselSpacing
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Carousel.spacing"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Carousel.html#g:attr:spacing"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Carousel
type instance O.AttributeList Carousel = CarouselAttributeList
type CarouselAttributeList = ('[ '("aboveChild", Gtk.EventBox.EventBoxAboveChildPropertyInfo), '("allowLongSwipes", CarouselAllowLongSwipesPropertyInfo), '("allowMouseDrag", CarouselAllowMouseDragPropertyInfo), '("allowScrollWheel", CarouselAllowScrollWheelPropertyInfo), '("animationDuration", CarouselAnimationDurationPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("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), '("interactive", CarouselInteractivePropertyInfo), '("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), '("nPages", CarouselNPagesPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("orientation", Gtk.Orientable.OrientableOrientationPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("position", CarouselPositionPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("revealDuration", CarouselRevealDurationPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("spacing", CarouselSpacingPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("visibleWindow", Gtk.EventBox.EventBoxVisibleWindowPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
carouselAllowLongSwipes :: AttrLabelProxy "allowLongSwipes"
carouselAllowLongSwipes = AttrLabelProxy

carouselAllowMouseDrag :: AttrLabelProxy "allowMouseDrag"
carouselAllowMouseDrag = AttrLabelProxy

carouselAllowScrollWheel :: AttrLabelProxy "allowScrollWheel"
carouselAllowScrollWheel = AttrLabelProxy

carouselAnimationDuration :: AttrLabelProxy "animationDuration"
carouselAnimationDuration = AttrLabelProxy

carouselInteractive :: AttrLabelProxy "interactive"
carouselInteractive = AttrLabelProxy

carouselNPages :: AttrLabelProxy "nPages"
carouselNPages = AttrLabelProxy

carouselPosition :: AttrLabelProxy "position"
carouselPosition = AttrLabelProxy

carouselRevealDuration :: AttrLabelProxy "revealDuration"
carouselRevealDuration = AttrLabelProxy

carouselSpacing :: AttrLabelProxy "spacing"
carouselSpacing = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Carousel = CarouselSignalList
type CarouselSignalList = ('[ '("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), '("pageChanged", CarouselPageChangedSignalInfo), '("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 Carousel::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Handy" , name = "Carousel" })
-- throws : False
-- Skip return : False

foreign import ccall "hdy_carousel_new" hdy_carousel_new :: 
    IO (Ptr Carousel)

-- | Create a new t'GI.Handy.Objects.Carousel.Carousel' widget.
-- 
-- /Since: 1.0/
carouselNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Carousel
    -- ^ __Returns:__ The newly created t'GI.Handy.Objects.Carousel.Carousel' widget
carouselNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Carousel
carouselNew  = IO Carousel -> m Carousel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Carousel -> m Carousel) -> IO Carousel -> m Carousel
forall a b. (a -> b) -> a -> b
$ do
    Ptr Carousel
result <- IO (Ptr Carousel)
hdy_carousel_new
    Text -> Ptr Carousel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"carouselNew" Ptr Carousel
result
    Carousel
result' <- ((ManagedPtr Carousel -> Carousel) -> Ptr Carousel -> IO Carousel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Carousel -> Carousel
Carousel) Ptr Carousel
result
    Carousel -> IO Carousel
forall (m :: * -> *) a. Monad m => a -> m a
return Carousel
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

-- | Whether to allow swiping for more than one page at a time. If the value is
-- 'P.False', each swipe can only move to the adjacent pages.
-- 
-- /Since: 1.2/
carouselGetAllowLongSwipes ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if long swipes are allowed, 'P.False' otherwise
carouselGetAllowLongSwipes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> m Bool
carouselGetAllowLongSwipes 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Carousel -> IO CInt
hdy_carousel_get_allow_long_swipes Ptr Carousel
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 CarouselGetAllowLongSwipesMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselGetAllowLongSwipesMethodInfo a signature where
    overloadedMethod = carouselGetAllowLongSwipes

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


#endif

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

-- | Sets whether /@self@/ can be dragged with mouse pointer
-- 
-- /Since: 1.0/
carouselGetAllowMouseDrag ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@self@/ can be dragged with mouse
carouselGetAllowMouseDrag :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> m Bool
carouselGetAllowMouseDrag 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Carousel -> IO CInt
hdy_carousel_get_allow_mouse_drag Ptr Carousel
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 CarouselGetAllowMouseDragMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselGetAllowMouseDragMethodInfo a signature where
    overloadedMethod = carouselGetAllowMouseDrag

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


#endif

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

-- | Gets whether /@self@/ will respond to scroll wheel events.
-- 
-- /Since: 1.4/
carouselGetAllowScrollWheel ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@self@/ will respond to scroll wheel events
carouselGetAllowScrollWheel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> m Bool
carouselGetAllowScrollWheel 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Carousel -> IO CInt
hdy_carousel_get_allow_scroll_wheel Ptr Carousel
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 CarouselGetAllowScrollWheelMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselGetAllowScrollWheelMethodInfo a signature where
    overloadedMethod = carouselGetAllowScrollWheel

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


#endif

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

-- | Gets animation duration used by 'GI.Handy.Objects.Carousel.carouselScrollTo'.
-- 
-- /Since: 1.0/
carouselGetAnimationDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> m Word32
    -- ^ __Returns:__ Animation duration in milliseconds
carouselGetAnimationDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> m Word32
carouselGetAnimationDuration 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Carousel -> IO Word32
hdy_carousel_get_animation_duration Ptr Carousel
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 CarouselGetAnimationDurationMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselGetAnimationDurationMethodInfo a signature where
    overloadedMethod = carouselGetAnimationDuration

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


#endif

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

-- | Gets whether /@self@/ can be navigated.
-- 
-- /Since: 1.0/
carouselGetInteractive ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@self@/ can be swiped
carouselGetInteractive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> m Bool
carouselGetInteractive 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Carousel -> IO CInt
hdy_carousel_get_interactive Ptr Carousel
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 CarouselGetInteractiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselGetInteractiveMethodInfo a signature where
    overloadedMethod = carouselGetInteractive

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


#endif

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

-- | Gets the number of pages in /@self@/.
-- 
-- /Since: 1.0/
carouselGetNPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> m Word32
    -- ^ __Returns:__ The number of pages in /@self@/
carouselGetNPages :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> m Word32
carouselGetNPages 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Carousel -> IO Word32
hdy_carousel_get_n_pages Ptr Carousel
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 CarouselGetNPagesMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselGetNPagesMethodInfo a signature where
    overloadedMethod = carouselGetNPages

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


#endif

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

foreign import ccall "hdy_carousel_get_position" hdy_carousel_get_position :: 
    Ptr Carousel ->                         -- self : TInterface (Name {namespace = "Handy", name = "Carousel"})
    IO CDouble

-- | Gets current scroll position in /@self@/. It\'s unitless, 1 matches 1 page.
-- 
-- /Since: 1.0/
carouselGetPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> m Double
    -- ^ __Returns:__ The scroll position
carouselGetPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> m Double
carouselGetPosition a
self = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr Carousel -> IO CDouble
hdy_carousel_get_position Ptr Carousel
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data CarouselGetPositionMethodInfo
instance (signature ~ (m Double), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselGetPositionMethodInfo a signature where
    overloadedMethod = carouselGetPosition

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


#endif

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

-- | Gets duration of the animation used when adding or removing pages in
-- milliseconds.
-- 
-- /Since: 1.0/
carouselGetRevealDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> m Word32
    -- ^ __Returns:__ Page reveal duration
carouselGetRevealDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> m Word32
carouselGetRevealDuration 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Carousel -> IO Word32
hdy_carousel_get_reveal_duration Ptr Carousel
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 CarouselGetRevealDurationMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselGetRevealDurationMethodInfo a signature where
    overloadedMethod = carouselGetRevealDuration

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


#endif

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

-- | Gets spacing between pages in pixels.
-- 
-- /Since: 1.0/
carouselGetSpacing ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> m Word32
    -- ^ __Returns:__ Spacing between pages
carouselGetSpacing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> m Word32
carouselGetSpacing 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Carousel -> IO Word32
hdy_carousel_get_spacing Ptr Carousel
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 CarouselGetSpacingMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselGetSpacingMethodInfo a signature where
    overloadedMethod = carouselGetSpacing

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


#endif

-- method Carousel::insert
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Carousel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyCarousel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget to add" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position to insert @child in."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_carousel_insert" hdy_carousel_insert :: 
    Ptr Carousel ->                         -- self : TInterface (Name {namespace = "Handy", name = "Carousel"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- position : TBasicType TInt
    IO ()

-- | Inserts /@child@/ into /@self@/ at position /@position@/.
-- 
-- If position is -1, or larger than the number of pages,
-- /@child@/ will be appended to the end.
-- 
-- /Since: 1.0/
carouselInsert ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> b
    -- ^ /@child@/: a widget to add
    -> Int32
    -- ^ /@position@/: the position to insert /@child@/ in.
    -> m ()
carouselInsert :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCarousel a, IsWidget b) =>
a -> b -> Int32 -> m ()
carouselInsert a
self b
child Int32
position = 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 Carousel
self' <- a -> IO (Ptr Carousel)
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 Carousel -> Ptr Widget -> Int32 -> IO ()
hdy_carousel_insert Ptr Carousel
self' Ptr Widget
child' Int32
position
    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 CarouselInsertMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsCarousel a, Gtk.Widget.IsWidget b) => O.OverloadedMethod CarouselInsertMethodInfo a signature where
    overloadedMethod = carouselInsert

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


#endif

-- method Carousel::prepend
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Carousel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyCarousel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget to add" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Prepends /@child@/ to /@self@/
-- 
-- /Since: 1.0/
carouselPrepend ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> b
    -- ^ /@child@/: a widget to add
    -> m ()
carouselPrepend :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCarousel a, IsWidget b) =>
a -> b -> m ()
carouselPrepend 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 Carousel
self' <- a -> IO (Ptr Carousel)
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 Carousel -> Ptr Widget -> IO ()
hdy_carousel_prepend Ptr Carousel
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 CarouselPrependMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsCarousel a, Gtk.Widget.IsWidget b) => O.OverloadedMethod CarouselPrependMethodInfo a signature where
    overloadedMethod = carouselPrepend

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


#endif

-- method Carousel::reorder
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Carousel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyCarousel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget to add" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position to move @child to."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_carousel_reorder" hdy_carousel_reorder :: 
    Ptr Carousel ->                         -- self : TInterface (Name {namespace = "Handy", name = "Carousel"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- position : TBasicType TInt
    IO ()

-- | Moves /@child@/ into position /@position@/.
-- 
-- If position is -1, or larger than the number of pages, /@child@/ will be moved
-- to the end.
-- 
-- /Since: 1.0/
carouselReorder ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> b
    -- ^ /@child@/: a widget to add
    -> Int32
    -- ^ /@position@/: the position to move /@child@/ to.
    -> m ()
carouselReorder :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCarousel a, IsWidget b) =>
a -> b -> Int32 -> m ()
carouselReorder a
self b
child Int32
position = 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 Carousel
self' <- a -> IO (Ptr Carousel)
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 Carousel -> Ptr Widget -> Int32 -> IO ()
hdy_carousel_reorder Ptr Carousel
self' Ptr Widget
child' Int32
position
    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 CarouselReorderMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsCarousel a, Gtk.Widget.IsWidget b) => O.OverloadedMethod CarouselReorderMethodInfo a signature where
    overloadedMethod = carouselReorder

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


#endif

-- method Carousel::scroll_to
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Carousel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyCarousel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child of @self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Scrolls to /@widget@/ position with an animation.
-- t'GI.Handy.Objects.Carousel.Carousel':@/animation-duration/@ property can be used for controlling the
-- duration.
-- 
-- /Since: 1.0/
carouselScrollTo ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> b
    -- ^ /@widget@/: a child of /@self@/
    -> m ()
carouselScrollTo :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCarousel a, IsWidget b) =>
a -> b -> m ()
carouselScrollTo a
self b
widget = 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Carousel -> Ptr Widget -> IO ()
hdy_carousel_scroll_to Ptr Carousel
self' Ptr Widget
widget'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method Carousel::scroll_to_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Carousel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyCarousel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child of @self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "duration"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "animation 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_carousel_scroll_to_full" hdy_carousel_scroll_to_full :: 
    Ptr Carousel ->                         -- self : TInterface (Name {namespace = "Handy", name = "Carousel"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int64 ->                                -- duration : TBasicType TInt64
    IO ()

-- | Scrolls to /@widget@/ position with an animation.
-- 
-- /Since: 1.0/
carouselScrollToFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> b
    -- ^ /@widget@/: a child of /@self@/
    -> Int64
    -- ^ /@duration@/: animation duration in milliseconds
    -> m ()
carouselScrollToFull :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCarousel a, IsWidget b) =>
a -> b -> Int64 -> m ()
carouselScrollToFull a
self b
widget Int64
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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Carousel -> Ptr Widget -> Int64 -> IO ()
hdy_carousel_scroll_to_full Ptr Carousel
self' Ptr Widget
widget' Int64
duration
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CarouselScrollToFullMethodInfo
instance (signature ~ (b -> Int64 -> m ()), MonadIO m, IsCarousel a, Gtk.Widget.IsWidget b) => O.OverloadedMethod CarouselScrollToFullMethodInfo a signature where
    overloadedMethod = carouselScrollToFull

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


#endif

-- method Carousel::set_allow_long_swipes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Carousel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyCarousel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_long_swipes"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to allow long swipes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_carousel_set_allow_long_swipes" hdy_carousel_set_allow_long_swipes :: 
    Ptr Carousel ->                         -- self : TInterface (Name {namespace = "Handy", name = "Carousel"})
    CInt ->                                 -- allow_long_swipes : TBasicType TBoolean
    IO ()

-- | Sets whether to allow swiping for more than one page at a time. If the value
-- is 'P.False', each swipe can only move to the adjacent pages.
-- 
-- /Since: 1.2/
carouselSetAllowLongSwipes ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> Bool
    -- ^ /@allowLongSwipes@/: whether to allow long swipes
    -> m ()
carouselSetAllowLongSwipes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> Bool -> m ()
carouselSetAllowLongSwipes a
self Bool
allowLongSwipes = 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let allowLongSwipes' :: CInt
allowLongSwipes' = (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
allowLongSwipes
    Ptr Carousel -> CInt -> IO ()
hdy_carousel_set_allow_long_swipes Ptr Carousel
self' CInt
allowLongSwipes'
    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 CarouselSetAllowLongSwipesMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselSetAllowLongSwipesMethodInfo a signature where
    overloadedMethod = carouselSetAllowLongSwipes

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


#endif

-- method Carousel::set_allow_mouse_drag
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Carousel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyCarousel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_mouse_drag"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether @self can be dragged with mouse pointer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_carousel_set_allow_mouse_drag" hdy_carousel_set_allow_mouse_drag :: 
    Ptr Carousel ->                         -- self : TInterface (Name {namespace = "Handy", name = "Carousel"})
    CInt ->                                 -- allow_mouse_drag : TBasicType TBoolean
    IO ()

-- | Sets whether /@self@/ can be dragged with mouse pointer. If /@allowMouseDrag@/
-- is 'P.False', dragging is only available on touch.
-- 
-- /Since: 1.0/
carouselSetAllowMouseDrag ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> Bool
    -- ^ /@allowMouseDrag@/: whether /@self@/ can be dragged with mouse pointer
    -> m ()
carouselSetAllowMouseDrag :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> Bool -> m ()
carouselSetAllowMouseDrag a
self Bool
allowMouseDrag = 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let allowMouseDrag' :: CInt
allowMouseDrag' = (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
allowMouseDrag
    Ptr Carousel -> CInt -> IO ()
hdy_carousel_set_allow_mouse_drag Ptr Carousel
self' CInt
allowMouseDrag'
    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 CarouselSetAllowMouseDragMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselSetAllowMouseDragMethodInfo a signature where
    overloadedMethod = carouselSetAllowMouseDrag

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


#endif

-- method Carousel::set_allow_scroll_wheel
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Carousel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyCarousel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_scroll_wheel"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether @self will respond to scroll wheel events."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_carousel_set_allow_scroll_wheel" hdy_carousel_set_allow_scroll_wheel :: 
    Ptr Carousel ->                         -- self : TInterface (Name {namespace = "Handy", name = "Carousel"})
    CInt ->                                 -- allow_scroll_wheel : TBasicType TBoolean
    IO ()

-- | Sets whether /@self@/ will respond to scroll wheel events. If the value is
-- 'P.False', wheel events will be ignored.
-- 
-- /Since: 1.4/
carouselSetAllowScrollWheel ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> Bool
    -- ^ /@allowScrollWheel@/: whether /@self@/ will respond to scroll wheel events.
    -> m ()
carouselSetAllowScrollWheel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> Bool -> m ()
carouselSetAllowScrollWheel a
self Bool
allowScrollWheel = 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let allowScrollWheel' :: CInt
allowScrollWheel' = (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
allowScrollWheel
    Ptr Carousel -> CInt -> IO ()
hdy_carousel_set_allow_scroll_wheel Ptr Carousel
self' CInt
allowScrollWheel'
    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 CarouselSetAllowScrollWheelMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselSetAllowScrollWheelMethodInfo a signature where
    overloadedMethod = carouselSetAllowScrollWheel

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


#endif

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

-- | Sets animation duration used by 'GI.Handy.Objects.Carousel.carouselScrollTo'.
-- 
-- /Since: 1.0/
carouselSetAnimationDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> Word32
    -- ^ /@duration@/: animation duration in milliseconds
    -> m ()
carouselSetAnimationDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> Word32 -> m ()
carouselSetAnimationDuration 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Carousel -> CarouselPageChangedCallback
hdy_carousel_set_animation_duration Ptr Carousel
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 CarouselSetAnimationDurationMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselSetAnimationDurationMethodInfo a signature where
    overloadedMethod = carouselSetAnimationDuration

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


#endif

-- method Carousel::set_interactive
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Carousel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyCarousel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interactive"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether @self can be swiped."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_carousel_set_interactive" hdy_carousel_set_interactive :: 
    Ptr Carousel ->                         -- self : TInterface (Name {namespace = "Handy", name = "Carousel"})
    CInt ->                                 -- interactive : TBasicType TBoolean
    IO ()

-- | Sets whether /@self@/ can be navigated. This can be used to temporarily disable
-- a t'GI.Handy.Objects.Carousel.Carousel' to only allow swiping in a certain state.
-- 
-- /Since: 1.0/
carouselSetInteractive ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> Bool
    -- ^ /@interactive@/: whether /@self@/ can be swiped.
    -> m ()
carouselSetInteractive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> Bool -> m ()
carouselSetInteractive a
self Bool
interactive = 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let interactive' :: CInt
interactive' = (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
interactive
    Ptr Carousel -> CInt -> IO ()
hdy_carousel_set_interactive Ptr Carousel
self' CInt
interactive'
    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 CarouselSetInteractiveMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselSetInteractiveMethodInfo a signature where
    overloadedMethod = carouselSetInteractive

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


#endif

-- method Carousel::set_reveal_duration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Carousel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyCarousel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "reveal_duration"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new reveal duration 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_carousel_set_reveal_duration" hdy_carousel_set_reveal_duration :: 
    Ptr Carousel ->                         -- self : TInterface (Name {namespace = "Handy", name = "Carousel"})
    Word32 ->                               -- reveal_duration : TBasicType TUInt
    IO ()

-- | Sets duration of the animation used when adding or removing pages in
-- milliseconds.
-- 
-- /Since: 1.0/
carouselSetRevealDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> Word32
    -- ^ /@revealDuration@/: the new reveal duration value
    -> m ()
carouselSetRevealDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> Word32 -> m ()
carouselSetRevealDuration a
self Word32
revealDuration = 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Carousel -> CarouselPageChangedCallback
hdy_carousel_set_reveal_duration Ptr Carousel
self' Word32
revealDuration
    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 CarouselSetRevealDurationMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselSetRevealDurationMethodInfo a signature where
    overloadedMethod = carouselSetRevealDuration

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


#endif

-- method Carousel::set_spacing
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Carousel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyCarousel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "spacing"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new spacing 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_carousel_set_spacing" hdy_carousel_set_spacing :: 
    Ptr Carousel ->                         -- self : TInterface (Name {namespace = "Handy", name = "Carousel"})
    Word32 ->                               -- spacing : TBasicType TUInt
    IO ()

-- | Sets spacing between pages in pixels.
-- 
-- /Since: 1.0/
carouselSetSpacing ::
    (B.CallStack.HasCallStack, MonadIO m, IsCarousel a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Carousel.Carousel'
    -> Word32
    -- ^ /@spacing@/: the new spacing value
    -> m ()
carouselSetSpacing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCarousel a) =>
a -> Word32 -> m ()
carouselSetSpacing a
self Word32
spacing = 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 Carousel
self' <- a -> IO (Ptr Carousel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Carousel -> CarouselPageChangedCallback
hdy_carousel_set_spacing Ptr Carousel
self' Word32
spacing
    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 CarouselSetSpacingMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsCarousel a) => O.OverloadedMethod CarouselSetSpacingMethodInfo a signature where
    overloadedMethod = carouselSetSpacing

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


#endif