{-# LANGUAGE TypeApplications #-}


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

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

module GI.Handy.Objects.Deck
    ( 

-- * Exported types
    Deck(..)                                ,
    IsDeck                                  ,
    toDeck                                  ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveDeckMethod                       ,
#endif

-- ** getAdjacentChild #method:getAdjacentChild#

#if defined(ENABLE_OVERLOADING)
    DeckGetAdjacentChildMethodInfo          ,
#endif
    deckGetAdjacentChild                    ,


-- ** getCanSwipeBack #method:getCanSwipeBack#

#if defined(ENABLE_OVERLOADING)
    DeckGetCanSwipeBackMethodInfo           ,
#endif
    deckGetCanSwipeBack                     ,


-- ** getCanSwipeForward #method:getCanSwipeForward#

#if defined(ENABLE_OVERLOADING)
    DeckGetCanSwipeForwardMethodInfo        ,
#endif
    deckGetCanSwipeForward                  ,


-- ** getChildByName #method:getChildByName#

#if defined(ENABLE_OVERLOADING)
    DeckGetChildByNameMethodInfo            ,
#endif
    deckGetChildByName                      ,


-- ** getHomogeneous #method:getHomogeneous#

#if defined(ENABLE_OVERLOADING)
    DeckGetHomogeneousMethodInfo            ,
#endif
    deckGetHomogeneous                      ,


-- ** getInterpolateSize #method:getInterpolateSize#

#if defined(ENABLE_OVERLOADING)
    DeckGetInterpolateSizeMethodInfo        ,
#endif
    deckGetInterpolateSize                  ,


-- ** getTransitionDuration #method:getTransitionDuration#

#if defined(ENABLE_OVERLOADING)
    DeckGetTransitionDurationMethodInfo     ,
#endif
    deckGetTransitionDuration               ,


-- ** getTransitionRunning #method:getTransitionRunning#

#if defined(ENABLE_OVERLOADING)
    DeckGetTransitionRunningMethodInfo      ,
#endif
    deckGetTransitionRunning                ,


-- ** getTransitionType #method:getTransitionType#

#if defined(ENABLE_OVERLOADING)
    DeckGetTransitionTypeMethodInfo         ,
#endif
    deckGetTransitionType                   ,


-- ** getVisibleChild #method:getVisibleChild#

#if defined(ENABLE_OVERLOADING)
    DeckGetVisibleChildMethodInfo           ,
#endif
    deckGetVisibleChild                     ,


-- ** getVisibleChildName #method:getVisibleChildName#

#if defined(ENABLE_OVERLOADING)
    DeckGetVisibleChildNameMethodInfo       ,
#endif
    deckGetVisibleChildName                 ,


-- ** insertChildAfter #method:insertChildAfter#

#if defined(ENABLE_OVERLOADING)
    DeckInsertChildAfterMethodInfo          ,
#endif
    deckInsertChildAfter                    ,


-- ** navigate #method:navigate#

#if defined(ENABLE_OVERLOADING)
    DeckNavigateMethodInfo                  ,
#endif
    deckNavigate                            ,


-- ** new #method:new#

    deckNew                                 ,


-- ** prepend #method:prepend#

#if defined(ENABLE_OVERLOADING)
    DeckPrependMethodInfo                   ,
#endif
    deckPrepend                             ,


-- ** reorderChildAfter #method:reorderChildAfter#

#if defined(ENABLE_OVERLOADING)
    DeckReorderChildAfterMethodInfo         ,
#endif
    deckReorderChildAfter                   ,


-- ** setCanSwipeBack #method:setCanSwipeBack#

#if defined(ENABLE_OVERLOADING)
    DeckSetCanSwipeBackMethodInfo           ,
#endif
    deckSetCanSwipeBack                     ,


-- ** setCanSwipeForward #method:setCanSwipeForward#

#if defined(ENABLE_OVERLOADING)
    DeckSetCanSwipeForwardMethodInfo        ,
#endif
    deckSetCanSwipeForward                  ,


-- ** setHomogeneous #method:setHomogeneous#

#if defined(ENABLE_OVERLOADING)
    DeckSetHomogeneousMethodInfo            ,
#endif
    deckSetHomogeneous                      ,


-- ** setInterpolateSize #method:setInterpolateSize#

#if defined(ENABLE_OVERLOADING)
    DeckSetInterpolateSizeMethodInfo        ,
#endif
    deckSetInterpolateSize                  ,


-- ** setTransitionDuration #method:setTransitionDuration#

#if defined(ENABLE_OVERLOADING)
    DeckSetTransitionDurationMethodInfo     ,
#endif
    deckSetTransitionDuration               ,


-- ** setTransitionType #method:setTransitionType#

#if defined(ENABLE_OVERLOADING)
    DeckSetTransitionTypeMethodInfo         ,
#endif
    deckSetTransitionType                   ,


-- ** setVisibleChild #method:setVisibleChild#

#if defined(ENABLE_OVERLOADING)
    DeckSetVisibleChildMethodInfo           ,
#endif
    deckSetVisibleChild                     ,


-- ** setVisibleChildName #method:setVisibleChildName#

#if defined(ENABLE_OVERLOADING)
    DeckSetVisibleChildNameMethodInfo       ,
#endif
    deckSetVisibleChildName                 ,




 -- * Properties


-- ** canSwipeBack #attr:canSwipeBack#
-- | Whether or not the deck allows switching to the previous child via a swipe
-- gesture.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    DeckCanSwipeBackPropertyInfo            ,
#endif
    constructDeckCanSwipeBack               ,
#if defined(ENABLE_OVERLOADING)
    deckCanSwipeBack                        ,
#endif
    getDeckCanSwipeBack                     ,
    setDeckCanSwipeBack                     ,


-- ** canSwipeForward #attr:canSwipeForward#
-- | Whether or not the deck allows switching to the next child via a swipe
-- gesture.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    DeckCanSwipeForwardPropertyInfo         ,
#endif
    constructDeckCanSwipeForward            ,
#if defined(ENABLE_OVERLOADING)
    deckCanSwipeForward                     ,
#endif
    getDeckCanSwipeForward                  ,
    setDeckCanSwipeForward                  ,


-- ** hhomogeneous #attr:hhomogeneous#
-- | Horizontally homogeneous sizing.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    DeckHhomogeneousPropertyInfo            ,
#endif
    constructDeckHhomogeneous               ,
#if defined(ENABLE_OVERLOADING)
    deckHhomogeneous                        ,
#endif
    getDeckHhomogeneous                     ,
    setDeckHhomogeneous                     ,


-- ** interpolateSize #attr:interpolateSize#
-- | Whether or not the size should smoothly change when changing between
-- differently sized children.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    DeckInterpolateSizePropertyInfo         ,
#endif
    constructDeckInterpolateSize            ,
#if defined(ENABLE_OVERLOADING)
    deckInterpolateSize                     ,
#endif
    getDeckInterpolateSize                  ,
    setDeckInterpolateSize                  ,


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

#if defined(ENABLE_OVERLOADING)
    DeckTransitionDurationPropertyInfo      ,
#endif
    constructDeckTransitionDuration         ,
#if defined(ENABLE_OVERLOADING)
    deckTransitionDuration                  ,
#endif
    getDeckTransitionDuration               ,
    setDeckTransitionDuration               ,


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

#if defined(ENABLE_OVERLOADING)
    DeckTransitionRunningPropertyInfo       ,
#endif
#if defined(ENABLE_OVERLOADING)
    deckTransitionRunning                   ,
#endif
    getDeckTransitionRunning                ,


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

#if defined(ENABLE_OVERLOADING)
    DeckTransitionTypePropertyInfo          ,
#endif
    constructDeckTransitionType             ,
#if defined(ENABLE_OVERLOADING)
    deckTransitionType                      ,
#endif
    getDeckTransitionType                   ,
    setDeckTransitionType                   ,


-- ** vhomogeneous #attr:vhomogeneous#
-- | Vertically homogeneous sizing.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    DeckVhomogeneousPropertyInfo            ,
#endif
    constructDeckVhomogeneous               ,
#if defined(ENABLE_OVERLOADING)
    deckVhomogeneous                        ,
#endif
    getDeckVhomogeneous                     ,
    setDeckVhomogeneous                     ,


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

#if defined(ENABLE_OVERLOADING)
    DeckVisibleChildPropertyInfo            ,
#endif
    constructDeckVisibleChild               ,
#if defined(ENABLE_OVERLOADING)
    deckVisibleChild                        ,
#endif
    getDeckVisibleChild                     ,
    setDeckVisibleChild                     ,


-- ** visibleChildName #attr:visibleChildName#
-- | The name of the widget currently visible.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    DeckVisibleChildNamePropertyInfo        ,
#endif
    constructDeckVisibleChildName           ,
#if defined(ENABLE_OVERLOADING)
    deckVisibleChildName                    ,
#endif
    getDeckVisibleChildName                 ,
    setDeckVisibleChildName                 ,




    ) where

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

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

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

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

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

foreign import ccall "hdy_deck_get_type"
    c_hdy_deck_get_type :: IO B.Types.GType

instance B.Types.TypedObject Deck where
    glibType :: IO GType
glibType = IO GType
c_hdy_deck_get_type

instance B.Types.GObject Deck

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

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

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

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

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

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

#endif

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

#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data DeckTransitionTypePropertyInfo
instance AttrInfo DeckTransitionTypePropertyInfo where
    type AttrAllowedOps DeckTransitionTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DeckTransitionTypePropertyInfo = IsDeck
    type AttrSetTypeConstraint DeckTransitionTypePropertyInfo = (~) Handy.Enums.DeckTransitionType
    type AttrTransferTypeConstraint DeckTransitionTypePropertyInfo = (~) Handy.Enums.DeckTransitionType
    type AttrTransferType DeckTransitionTypePropertyInfo = Handy.Enums.DeckTransitionType
    type AttrGetType DeckTransitionTypePropertyInfo = Handy.Enums.DeckTransitionType
    type AttrLabel DeckTransitionTypePropertyInfo = "transition-type"
    type AttrOrigin DeckTransitionTypePropertyInfo = Deck
    attrGet = getDeckTransitionType
    attrSet = setDeckTransitionType
    attrTransfer _ v = do
        return v
    attrConstruct = constructDeckTransitionType
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Deck.transitionType"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Deck.html#g:attr:transitionType"
        })
#endif

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

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

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

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

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data DeckVisibleChildPropertyInfo
instance AttrInfo DeckVisibleChildPropertyInfo where
    type AttrAllowedOps DeckVisibleChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DeckVisibleChildPropertyInfo = IsDeck
    type AttrSetTypeConstraint DeckVisibleChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint DeckVisibleChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType DeckVisibleChildPropertyInfo = Gtk.Widget.Widget
    type AttrGetType DeckVisibleChildPropertyInfo = Gtk.Widget.Widget
    type AttrLabel DeckVisibleChildPropertyInfo = "visible-child"
    type AttrOrigin DeckVisibleChildPropertyInfo = Deck
    attrGet = getDeckVisibleChild
    attrSet = setDeckVisibleChild
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructDeckVisibleChild
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Deck.visibleChild"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Deck.html#g:attr:visibleChild"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data DeckVisibleChildNamePropertyInfo
instance AttrInfo DeckVisibleChildNamePropertyInfo where
    type AttrAllowedOps DeckVisibleChildNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DeckVisibleChildNamePropertyInfo = IsDeck
    type AttrSetTypeConstraint DeckVisibleChildNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint DeckVisibleChildNamePropertyInfo = (~) T.Text
    type AttrTransferType DeckVisibleChildNamePropertyInfo = T.Text
    type AttrGetType DeckVisibleChildNamePropertyInfo = T.Text
    type AttrLabel DeckVisibleChildNamePropertyInfo = "visible-child-name"
    type AttrOrigin DeckVisibleChildNamePropertyInfo = Deck
    attrGet = getDeckVisibleChildName
    attrSet = setDeckVisibleChildName
    attrTransfer _ v = do
        return v
    attrConstruct = constructDeckVisibleChildName
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Deck.visibleChildName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Deck.html#g:attr:visibleChildName"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Deck
type instance O.AttributeList Deck = DeckAttributeList
type DeckAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canSwipeBack", DeckCanSwipeBackPropertyInfo), '("canSwipeForward", DeckCanSwipeForwardPropertyInfo), '("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), '("hhomogeneous", DeckHhomogeneousPropertyInfo), '("interpolateSize", DeckInterpolateSizePropertyInfo), '("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), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("orientation", Gtk.Orientable.OrientableOrientationPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("transitionDuration", DeckTransitionDurationPropertyInfo), '("transitionRunning", DeckTransitionRunningPropertyInfo), '("transitionType", DeckTransitionTypePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("vhomogeneous", DeckVhomogeneousPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("visibleChild", DeckVisibleChildPropertyInfo), '("visibleChildName", DeckVisibleChildNamePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])
#endif

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

deckCanSwipeForward :: AttrLabelProxy "canSwipeForward"
deckCanSwipeForward = AttrLabelProxy

deckHhomogeneous :: AttrLabelProxy "hhomogeneous"
deckHhomogeneous = AttrLabelProxy

deckInterpolateSize :: AttrLabelProxy "interpolateSize"
deckInterpolateSize = AttrLabelProxy

deckTransitionDuration :: AttrLabelProxy "transitionDuration"
deckTransitionDuration = AttrLabelProxy

deckTransitionRunning :: AttrLabelProxy "transitionRunning"
deckTransitionRunning = AttrLabelProxy

deckTransitionType :: AttrLabelProxy "transitionType"
deckTransitionType = AttrLabelProxy

deckVhomogeneous :: AttrLabelProxy "vhomogeneous"
deckVhomogeneous = AttrLabelProxy

deckVisibleChild :: AttrLabelProxy "visibleChild"
deckVisibleChild = AttrLabelProxy

deckVisibleChildName :: AttrLabelProxy "visibleChildName"
deckVisibleChildName = AttrLabelProxy

#endif

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

#endif

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

foreign import ccall "hdy_deck_new" hdy_deck_new :: 
    IO (Ptr Deck)

-- | /No description available in the introspection data./
deckNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Deck
deckNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Deck
deckNew  = IO Deck -> m Deck
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Deck -> m Deck) -> IO Deck -> m Deck
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
result <- IO (Ptr Deck)
hdy_deck_new
    Text -> Ptr Deck -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"deckNew" Ptr Deck
result
    Deck
result' <- ((ManagedPtr Deck -> Deck) -> Ptr Deck -> IO Deck
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Deck -> Deck
Deck) Ptr Deck
result
    Deck -> IO Deck
forall (m :: * -> *) a. Monad m => a -> m a
return Deck
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "hdy_deck_get_adjacent_child" hdy_deck_get_adjacent_child :: 
    Ptr Deck ->                             -- self : TInterface (Name {namespace = "Handy", name = "Deck"})
    CUInt ->                                -- direction : TInterface (Name {namespace = "Handy", name = "NavigationDirection"})
    IO (Ptr Gtk.Widget.Widget)

-- | Gets the previous or next child, or 'P.Nothing' if it doesn\'t exist. This will be
-- the same widget 'GI.Handy.Objects.Deck.deckNavigate' will navigate to.
-- 
-- /Since: 1.0/
deckGetAdjacentChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> Handy.Enums.NavigationDirection
    -- ^ /@direction@/: the direction
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the previous or next child, or
    --   'P.Nothing' if it doesn\'t exist.
deckGetAdjacentChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> NavigationDirection -> m (Maybe Widget)
deckGetAdjacentChild a
self NavigationDirection
direction = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let direction' :: CUInt
direction' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (NavigationDirection -> Int) -> NavigationDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NavigationDirection -> Int
forall a. Enum a => a -> Int
fromEnum) NavigationDirection
direction
    Ptr Widget
result <- Ptr Deck -> CUInt -> IO (Ptr Widget)
hdy_deck_get_adjacent_child Ptr Deck
self' CUInt
direction'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(ENABLE_OVERLOADING)
data DeckGetAdjacentChildMethodInfo
instance (signature ~ (Handy.Enums.NavigationDirection -> m (Maybe Gtk.Widget.Widget)), MonadIO m, IsDeck a) => O.OverloadedMethod DeckGetAdjacentChildMethodInfo a signature where
    overloadedMethod = deckGetAdjacentChild

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


#endif

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

-- | Returns whether the t'GI.Handy.Objects.Deck.Deck' allows swiping to the previous child.
-- 
-- /Since: 1.0/
deckGetCanSwipeBack ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if back swipe is enabled.
deckGetCanSwipeBack :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> m Bool
deckGetCanSwipeBack 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 Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Deck -> IO CInt
hdy_deck_get_can_swipe_back Ptr Deck
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 DeckGetCanSwipeBackMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDeck a) => O.OverloadedMethod DeckGetCanSwipeBackMethodInfo a signature where
    overloadedMethod = deckGetCanSwipeBack

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


#endif

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

-- | Returns whether the t'GI.Handy.Objects.Deck.Deck' allows swiping to the next child.
-- 
-- /Since: 1.0/
deckGetCanSwipeForward ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if forward swipe is enabled.
deckGetCanSwipeForward :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> m Bool
deckGetCanSwipeForward 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 Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Deck -> IO CInt
hdy_deck_get_can_swipe_forward Ptr Deck
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 DeckGetCanSwipeForwardMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDeck a) => O.OverloadedMethod DeckGetCanSwipeForwardMethodInfo a signature where
    overloadedMethod = deckGetCanSwipeForward

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


#endif

-- method Deck::get_child_by_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Deck" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyDeck" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the child to find"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
-- throws : False
-- Skip return : False

foreign import ccall "hdy_deck_get_child_by_name" hdy_deck_get_child_by_name :: 
    Ptr Deck ->                             -- self : TInterface (Name {namespace = "Handy", name = "Deck"})
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr Gtk.Widget.Widget)

-- | Finds the child of /@self@/ with the name given as the argument. Returns 'P.Nothing'
-- if there is no child with this name.
-- 
-- /Since: 1.0/
deckGetChildByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> T.Text
    -- ^ /@name@/: the name of the child to find
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the requested child of /@self@/
deckGetChildByName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> Text -> m (Maybe Widget)
deckGetChildByName a
self Text
name = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Widget
result <- Ptr Deck -> CString -> IO (Ptr Widget)
hdy_deck_get_child_by_name Ptr Deck
self' CString
name'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

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

foreign import ccall "hdy_deck_get_homogeneous" hdy_deck_get_homogeneous :: 
    Ptr Deck ->                             -- self : TInterface (Name {namespace = "Handy", name = "Deck"})
    CUInt ->                                -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"})
    IO CInt

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

#if defined(ENABLE_OVERLOADING)
data DeckGetHomogeneousMethodInfo
instance (signature ~ (Gtk.Enums.Orientation -> m Bool), MonadIO m, IsDeck a) => O.OverloadedMethod DeckGetHomogeneousMethodInfo a signature where
    overloadedMethod = deckGetHomogeneous

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


#endif

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

-- | Returns whether the t'GI.Handy.Objects.Deck.Deck' is set up to interpolate between
-- the sizes of children on page switch.
-- 
-- /Since: 1.0/
deckGetInterpolateSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if child sizes are interpolated
deckGetInterpolateSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> m Bool
deckGetInterpolateSize 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 Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Deck -> IO CInt
hdy_deck_get_interpolate_size Ptr Deck
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 DeckGetInterpolateSizeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDeck a) => O.OverloadedMethod DeckGetInterpolateSizeMethodInfo a signature where
    overloadedMethod = deckGetInterpolateSize

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


#endif

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

-- | Returns the amount of time (in milliseconds) that
-- transitions between children in /@self@/ will take.
-- 
-- /Since: 1.0/
deckGetTransitionDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> m Word32
    -- ^ __Returns:__ the child transition duration
deckGetTransitionDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> m Word32
deckGetTransitionDuration 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 Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Deck -> IO Word32
hdy_deck_get_transition_duration Ptr Deck
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 DeckGetTransitionDurationMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsDeck a) => O.OverloadedMethod DeckGetTransitionDurationMethodInfo a signature where
    overloadedMethod = deckGetTransitionDuration

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


#endif

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

-- | Returns whether /@self@/ is currently in a transition from one page to
-- another.
-- 
-- /Since: 1.0/
deckGetTransitionRunning ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the transition is currently running, 'P.False' otherwise.
deckGetTransitionRunning :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> m Bool
deckGetTransitionRunning 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 Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Deck -> IO CInt
hdy_deck_get_transition_running Ptr Deck
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 DeckGetTransitionRunningMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDeck a) => O.OverloadedMethod DeckGetTransitionRunningMethodInfo a signature where
    overloadedMethod = deckGetTransitionRunning

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


#endif

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

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

-- | Gets the type of animation that will be used
-- for transitions between children in /@self@/.
-- 
-- /Since: 1.0/
deckGetTransitionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> m Handy.Enums.DeckTransitionType
    -- ^ __Returns:__ the current transition type of /@self@/
deckGetTransitionType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> m DeckTransitionType
deckGetTransitionType a
self = IO DeckTransitionType -> m DeckTransitionType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DeckTransitionType -> m DeckTransitionType)
-> IO DeckTransitionType -> m DeckTransitionType
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Deck -> IO CUInt
hdy_deck_get_transition_type Ptr Deck
self'
    let result' :: DeckTransitionType
result' = (Int -> DeckTransitionType
forall a. Enum a => Int -> a
toEnum (Int -> DeckTransitionType)
-> (CUInt -> Int) -> CUInt -> DeckTransitionType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DeckTransitionType -> IO DeckTransitionType
forall (m :: * -> *) a. Monad m => a -> m a
return DeckTransitionType
result'

#if defined(ENABLE_OVERLOADING)
data DeckGetTransitionTypeMethodInfo
instance (signature ~ (m Handy.Enums.DeckTransitionType), MonadIO m, IsDeck a) => O.OverloadedMethod DeckGetTransitionTypeMethodInfo a signature where
    overloadedMethod = deckGetTransitionType

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


#endif

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

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

-- | Gets the visible child widget.
-- 
-- /Since: 1.0/
deckGetVisibleChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> m Gtk.Widget.Widget
    -- ^ __Returns:__ the visible child widget
deckGetVisibleChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> m Widget
deckGetVisibleChild a
self = IO Widget -> m Widget
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Widget -> m Widget) -> IO Widget -> m Widget
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr Deck -> IO (Ptr Widget)
hdy_deck_get_visible_child Ptr Deck
self'
    Text -> Ptr Widget -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"deckGetVisibleChild" Ptr Widget
result
    Widget
result' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result'

#if defined(ENABLE_OVERLOADING)
data DeckGetVisibleChildMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsDeck a) => O.OverloadedMethod DeckGetVisibleChildMethodInfo a signature where
    overloadedMethod = deckGetVisibleChild

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


#endif

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

foreign import ccall "hdy_deck_get_visible_child_name" hdy_deck_get_visible_child_name :: 
    Ptr Deck ->                             -- self : TInterface (Name {namespace = "Handy", name = "Deck"})
    IO CString

-- | Gets the name of the currently visible child widget.
-- 
-- /Since: 1.0/
deckGetVisibleChildName ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> m T.Text
    -- ^ __Returns:__ the name of the visible child
deckGetVisibleChildName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> m Text
deckGetVisibleChildName a
self = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr Deck -> IO CString
hdy_deck_get_visible_child_name Ptr Deck
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"deckGetVisibleChildName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data DeckGetVisibleChildNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDeck a) => O.OverloadedMethod DeckGetVisibleChildNameMethodInfo a signature where
    overloadedMethod = deckGetVisibleChildName

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


#endif

-- method Deck::insert_child_after
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Deck" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyDeck" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GtkWidget to insert"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sibling"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the sibling after which to insert @child"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Inserts /@child@/ in the position after /@sibling@/ in the list of children.
-- If /@sibling@/ is 'P.Nothing', insert /@child@/ at the first position.
-- 
-- /Since: 1.2/
deckInsertChildAfter ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> b
    -- ^ /@child@/: the t'GI.Gtk.Objects.Widget.Widget' to insert
    -> Maybe (c)
    -- ^ /@sibling@/: the sibling after which to insert /@child@/
    -> m ()
deckInsertChildAfter :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsDeck a, IsWidget b, IsWidget c) =>
a -> b -> Maybe c -> m ()
deckInsertChildAfter a
self b
child Maybe c
sibling = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Widget
maybeSibling <- case Maybe c
sibling of
        Maybe c
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just c
jSibling -> do
            Ptr Widget
jSibling' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jSibling
            Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jSibling'
    Ptr Deck -> Ptr Widget -> Ptr Widget -> IO ()
hdy_deck_insert_child_after Ptr Deck
self' Ptr Widget
child' Ptr Widget
maybeSibling
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
sibling c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

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

foreign import ccall "hdy_deck_navigate" hdy_deck_navigate :: 
    Ptr Deck ->                             -- self : TInterface (Name {namespace = "Handy", name = "Deck"})
    CUInt ->                                -- direction : TInterface (Name {namespace = "Handy", name = "NavigationDirection"})
    IO CInt

-- | Switches to the previous or next child, similar to performing a swipe
-- gesture to go in /@direction@/.
-- 
-- /Since: 1.0/
deckNavigate ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> Handy.Enums.NavigationDirection
    -- ^ /@direction@/: the direction
    -> m Bool
    -- ^ __Returns:__ 'P.True' if visible child was changed, 'P.False' otherwise.
deckNavigate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> NavigationDirection -> m Bool
deckNavigate a
self NavigationDirection
direction = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let direction' :: CUInt
direction' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (NavigationDirection -> Int) -> NavigationDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NavigationDirection -> Int
forall a. Enum a => a -> Int
fromEnum) NavigationDirection
direction
    CInt
result <- Ptr Deck -> CUInt -> IO CInt
hdy_deck_navigate Ptr Deck
self' CUInt
direction'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DeckNavigateMethodInfo
instance (signature ~ (Handy.Enums.NavigationDirection -> m Bool), MonadIO m, IsDeck a) => O.OverloadedMethod DeckNavigateMethodInfo a signature where
    overloadedMethod = deckNavigate

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


#endif

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

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

-- | Inserts /@child@/ at the first position in /@self@/.
-- 
-- /Since: 1.2/
deckPrepend ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> b
    -- ^ /@child@/: the t'GI.Gtk.Objects.Widget.Widget' to prepend
    -> m ()
deckPrepend :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDeck a, IsWidget b) =>
a -> b -> m ()
deckPrepend 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 Deck
self' <- a -> IO (Ptr Deck)
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 Deck -> Ptr Widget -> IO ()
hdy_deck_prepend Ptr Deck
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 DeckPrependMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDeck a, Gtk.Widget.IsWidget b) => O.OverloadedMethod DeckPrependMethodInfo a signature where
    overloadedMethod = deckPrepend

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


#endif

-- method Deck::reorder_child_after
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Deck" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyDeck" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GtkWidget to move, must be a child of @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sibling"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the sibling to move @child after, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Moves /@child@/ to the position after /@sibling@/ in the list of children.
-- If /@sibling@/ is 'P.Nothing', move /@child@/ to the first position.
-- 
-- /Since: 1.2/
deckReorderChildAfter ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> b
    -- ^ /@child@/: the t'GI.Gtk.Objects.Widget.Widget' to move, must be a child of /@self@/
    -> Maybe (c)
    -- ^ /@sibling@/: the sibling to move /@child@/ after, or 'P.Nothing'
    -> m ()
deckReorderChildAfter :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsDeck a, IsWidget b, IsWidget c) =>
a -> b -> Maybe c -> m ()
deckReorderChildAfter a
self b
child Maybe c
sibling = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Widget
maybeSibling <- case Maybe c
sibling of
        Maybe c
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just c
jSibling -> do
            Ptr Widget
jSibling' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jSibling
            Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jSibling'
    Ptr Deck -> Ptr Widget -> Ptr Widget -> IO ()
hdy_deck_reorder_child_after Ptr Deck
self' Ptr Widget
child' Ptr Widget
maybeSibling
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
sibling c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method Deck::set_can_swipe_back
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Deck" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyDeck" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "can_swipe_back"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether or not /@self@/ allows switching to the previous child via a swipe
-- gesture.
-- 
-- /Since: 1.0/
deckSetCanSwipeBack ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> Bool
    -- ^ /@canSwipeBack@/: the new value
    -> m ()
deckSetCanSwipeBack :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> Bool -> m ()
deckSetCanSwipeBack a
self Bool
canSwipeBack = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let canSwipeBack' :: CInt
canSwipeBack' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
canSwipeBack
    Ptr Deck -> CInt -> IO ()
hdy_deck_set_can_swipe_back Ptr Deck
self' CInt
canSwipeBack'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DeckSetCanSwipeBackMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDeck a) => O.OverloadedMethod DeckSetCanSwipeBackMethodInfo a signature where
    overloadedMethod = deckSetCanSwipeBack

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


#endif

-- method Deck::set_can_swipe_forward
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Deck" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyDeck" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "can_swipe_forward"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether or not /@self@/ allows switching to the next child via a swipe
-- gesture.
-- 
-- /Since: 1.0/
deckSetCanSwipeForward ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> Bool
    -- ^ /@canSwipeForward@/: the new value
    -> m ()
deckSetCanSwipeForward :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> Bool -> m ()
deckSetCanSwipeForward a
self Bool
canSwipeForward = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let canSwipeForward' :: CInt
canSwipeForward' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
canSwipeForward
    Ptr Deck -> CInt -> IO ()
hdy_deck_set_can_swipe_forward Ptr Deck
self' CInt
canSwipeForward'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DeckSetCanSwipeForwardMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDeck a) => O.OverloadedMethod DeckSetCanSwipeForwardMethodInfo a signature where
    overloadedMethod = deckSetCanSwipeForward

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


#endif

-- method Deck::set_homogeneous
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Deck" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyDeck" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "orientation"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Orientation" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the orientation" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "homogeneous"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to make @self homogeneous"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_deck_set_homogeneous" hdy_deck_set_homogeneous :: 
    Ptr Deck ->                             -- self : TInterface (Name {namespace = "Handy", name = "Deck"})
    CUInt ->                                -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"})
    CInt ->                                 -- homogeneous : TBasicType TBoolean
    IO ()

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

#if defined(ENABLE_OVERLOADING)
data DeckSetHomogeneousMethodInfo
instance (signature ~ (Gtk.Enums.Orientation -> Bool -> m ()), MonadIO m, IsDeck a) => O.OverloadedMethod DeckSetHomogeneousMethodInfo a signature where
    overloadedMethod = deckSetHomogeneous

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


#endif

-- method Deck::set_interpolate_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Deck" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyDeck" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interpolate_size"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

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

#if defined(ENABLE_OVERLOADING)
data DeckSetInterpolateSizeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDeck a) => O.OverloadedMethod DeckSetInterpolateSizeMethodInfo a signature where
    overloadedMethod = deckSetInterpolateSize

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


#endif

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

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

-- | Sets the duration that transitions between children in /@self@/
-- will take.
-- 
-- /Since: 1.0/
deckSetTransitionDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> Word32
    -- ^ /@duration@/: the new duration, in milliseconds
    -> m ()
deckSetTransitionDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> Word32 -> m ()
deckSetTransitionDuration 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 Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Deck -> Word32 -> IO ()
hdy_deck_set_transition_duration Ptr Deck
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 DeckSetTransitionDurationMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDeck a) => O.OverloadedMethod DeckSetTransitionDurationMethodInfo a signature where
    overloadedMethod = deckSetTransitionDuration

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


#endif

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

foreign import ccall "hdy_deck_set_transition_type" hdy_deck_set_transition_type :: 
    Ptr Deck ->                             -- self : TInterface (Name {namespace = "Handy", name = "Deck"})
    CUInt ->                                -- transition : TInterface (Name {namespace = "Handy", name = "DeckTransitionType"})
    IO ()

-- | Sets the type of animation that will be used for transitions between children
-- in /@self@/.
-- 
-- The transition type can be changed without problems at runtime, so it is
-- possible to change the animation based on the child that is about to become
-- current.
-- 
-- /Since: 1.0/
deckSetTransitionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> Handy.Enums.DeckTransitionType
    -- ^ /@transition@/: the new transition type
    -> m ()
deckSetTransitionType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> DeckTransitionType -> m ()
deckSetTransitionType a
self DeckTransitionType
transition = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let transition' :: CUInt
transition' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (DeckTransitionType -> Int) -> DeckTransitionType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DeckTransitionType -> Int
forall a. Enum a => a -> Int
fromEnum) DeckTransitionType
transition
    Ptr Deck -> CUInt -> IO ()
hdy_deck_set_transition_type Ptr Deck
self' CUInt
transition'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DeckSetTransitionTypeMethodInfo
instance (signature ~ (Handy.Enums.DeckTransitionType -> m ()), MonadIO m, IsDeck a) => O.OverloadedMethod DeckSetTransitionTypeMethodInfo a signature where
    overloadedMethod = deckSetTransitionType

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


#endif

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

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

-- | Makes /@visibleChild@/ visible using a transition determined by
-- HdyDeck:transition-type and HdyDeck:transition-duration. The transition can
-- be cancelled by the user, in which case visible child will change back to
-- the previously visible child.
-- 
-- /Since: 1.0/
deckSetVisibleChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> b
    -- ^ /@visibleChild@/: the new child
    -> m ()
deckSetVisibleChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDeck a, IsWidget b) =>
a -> b -> m ()
deckSetVisibleChild a
self b
visibleChild = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
visibleChild' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
visibleChild
    Ptr Deck -> Ptr Widget -> IO ()
hdy_deck_set_visible_child Ptr Deck
self' Ptr Widget
visibleChild'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
visibleChild
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method Deck::set_visible_child_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Deck" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyDeck" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of a child"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_deck_set_visible_child_name" hdy_deck_set_visible_child_name :: 
    Ptr Deck ->                             -- self : TInterface (Name {namespace = "Handy", name = "Deck"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Makes the child with the name /@name@/ visible.
-- 
-- See 'GI.Handy.Objects.Deck.deckSetVisibleChild' for more details.
-- 
-- /Since: 1.0/
deckSetVisibleChildName ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeck a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Deck.Deck'
    -> T.Text
    -- ^ /@name@/: the name of a child
    -> m ()
deckSetVisibleChildName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeck a) =>
a -> Text -> m ()
deckSetVisibleChildName a
self Text
name = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Deck
self' <- a -> IO (Ptr Deck)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Deck -> CString -> IO ()
hdy_deck_set_visible_child_name Ptr Deck
self' CString
name'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif