{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An adaptive container acting like a box or an overlay.
-- 
-- The @HdyFlap@ widget can display its children like a t'GI.Gtk.Objects.Box.Box' does or
-- like a t'GI.Gtk.Objects.Overlay.Overlay' does, according to the
-- [property/@flap@/:fold-policy] value.
-- 
-- @HdyFlap@ has at most three children: [property/@flap@/:content],
-- [property/@flap@/:flap] and [property/@flap@/:separator]. Content is the primary
-- child, flap is displayed next to it when unfolded, or overlays it when
-- folded. Flap can be shown or hidden by changing the
-- [property/@flap@/:reveal-flap] value, as well as via swipe gestures if
-- [property/@flap@/:swipe-to-open] and\/or [property/@flap@/:swipe-to-close] are set
-- to @TRUE@.
-- 
-- Optionally, a separator can be provided, which would be displayed between the
-- content and the flap when there\'s no shadow to separate them, depending on
-- the transition type.
-- 
-- [property/@flap@/:flap] is transparent by default; add the @.background@ style
-- class to it if this is unwanted.
-- 
-- If [property/@flap@/:modal] is set to @TRUE@, content becomes completely
-- inaccessible when the flap is revealed while folded.
-- 
-- The position of the flap and separator children relative to the content is
-- determined by orientation, as well as the [property/@flap@/:flap-position]
-- value.
-- 
-- Folding the flap will automatically hide the flap widget, and unfolding it
-- will automatically reveal it. If this behavior is not desired, the
-- [property/@flap@/:locked] property can be used to override it.
-- 
-- Common use cases include sidebars, header bars that need to be able to
-- overlap the window content (for example, in fullscreen mode) and bottom
-- sheets.
-- 
-- == HdyFlap as GtkBuildable
-- 
-- The @HdyFlap@ implementation of the t'GI.Gtk.Interfaces.Buildable.Buildable' interface supports
-- setting the flap child by specifying “flap” as the “type” attribute of a
-- \<child> element, and separator by specifying “separator”. Specifying
-- “content” child type or omitting it results in setting the content child.
-- 
-- == CSS nodes
-- 
-- @HdyFlap@ has a single CSS node with name @flap@. The node will get the style
-- classes @.folded@ when it is folded, and @.unfolded@ when it\'s not.
-- 
-- /Since: 1.2/

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

module GI.Handy.Objects.Flap
    ( 

-- * Exported types
    Flap(..)                                ,
    IsFlap                                  ,
    toFlap                                  ,


 -- * 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"), [intersect]("GI.Gtk.Objects.Widget#g:method:intersect"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isComposited]("GI.Gtk.Objects.Widget#g:method:isComposited"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isToplevel]("GI.Gtk.Objects.Widget#g:method:isToplevel"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listAccelClosures]("GI.Gtk.Objects.Widget#g:method:listAccelClosures"), [listActionPrefixes]("GI.Gtk.Objects.Widget#g:method:listActionPrefixes"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [modifyBase]("GI.Gtk.Objects.Widget#g:method:modifyBase"), [modifyBg]("GI.Gtk.Objects.Widget#g:method:modifyBg"), [modifyCursor]("GI.Gtk.Objects.Widget#g:method:modifyCursor"), [modifyFg]("GI.Gtk.Objects.Widget#g:method:modifyFg"), [modifyFont]("GI.Gtk.Objects.Widget#g:method:modifyFont"), [modifyStyle]("GI.Gtk.Objects.Widget#g:method:modifyStyle"), [modifyText]("GI.Gtk.Objects.Widget#g:method:modifyText"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [overrideBackgroundColor]("GI.Gtk.Objects.Widget#g:method:overrideBackgroundColor"), [overrideColor]("GI.Gtk.Objects.Widget#g:method:overrideColor"), [overrideCursor]("GI.Gtk.Objects.Widget#g:method:overrideCursor"), [overrideFont]("GI.Gtk.Objects.Widget#g:method:overrideFont"), [overrideSymbolicColor]("GI.Gtk.Objects.Widget#g:method:overrideSymbolicColor"), [parserFinished]("GI.Gtk.Interfaces.Buildable#g:method:parserFinished"), [path]("GI.Gtk.Objects.Widget#g:method:path"), [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"), [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"), [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"), [getCancelProgress]("GI.Handy.Interfaces.Swipeable#g:method:getCancelProgress"), [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"), [getContent]("GI.Handy.Objects.Flap#g:method:getContent"), [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"), [getFlap]("GI.Handy.Objects.Flap#g:method:getFlap"), [getFlapPosition]("GI.Handy.Objects.Flap#g:method:getFlapPosition"), [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"), [getFoldDuration]("GI.Handy.Objects.Flap#g:method:getFoldDuration"), [getFoldPolicy]("GI.Handy.Objects.Flap#g:method:getFoldPolicy"), [getFolded]("GI.Handy.Objects.Flap#g:method:getFolded"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHasWindow]("GI.Gtk.Objects.Widget#g:method:getHasWindow"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getInternalChild]("GI.Gtk.Interfaces.Buildable#g:method:getInternalChild"), [getLocked]("GI.Handy.Objects.Flap#g:method:getLocked"), [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"), [getModal]("GI.Handy.Objects.Flap#g:method:getModal"), [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"), [getRevealDuration]("GI.Handy.Objects.Flap#g:method:getRevealDuration"), [getRevealFlap]("GI.Handy.Objects.Flap#g:method:getRevealFlap"), [getRevealProgress]("GI.Handy.Objects.Flap#g:method:getRevealProgress"), [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"), [getSeparator]("GI.Handy.Objects.Flap#g:method:getSeparator"), [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"), [getSwipeToClose]("GI.Handy.Objects.Flap#g:method:getSwipeToClose"), [getSwipeToOpen]("GI.Handy.Objects.Flap#g:method:getSwipeToOpen"), [getSwipeTracker]("GI.Handy.Interfaces.Swipeable#g:method:getSwipeTracker"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTooltipWindow]("GI.Gtk.Objects.Widget#g:method:getTooltipWindow"), [getToplevel]("GI.Gtk.Objects.Widget#g:method:getToplevel"), [getTransitionType]("GI.Handy.Objects.Flap#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"), [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"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setClip]("GI.Gtk.Objects.Widget#g:method:setClip"), [setCompositeName]("GI.Gtk.Objects.Widget#g:method:setCompositeName"), [setContent]("GI.Handy.Objects.Flap#g:method:setContent"), [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"), [setFlap]("GI.Handy.Objects.Flap#g:method:setFlap"), [setFlapPosition]("GI.Handy.Objects.Flap#g:method:setFlapPosition"), [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"), [setFoldDuration]("GI.Handy.Objects.Flap#g:method:setFoldDuration"), [setFoldPolicy]("GI.Handy.Objects.Flap#g:method:setFoldPolicy"), [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"), [setLocked]("GI.Handy.Objects.Flap#g:method:setLocked"), [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"), [setModal]("GI.Handy.Objects.Flap#g:method:setModal"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNoShowAll]("GI.Gtk.Objects.Widget#g:method:setNoShowAll"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOrientation]("GI.Gtk.Interfaces.Orientable#g:method:setOrientation"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setParentWindow]("GI.Gtk.Objects.Widget#g:method:setParentWindow"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRealized]("GI.Gtk.Objects.Widget#g:method:setRealized"), [setReallocateRedraws]("GI.Gtk.Objects.Container#g:method:setReallocateRedraws"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setRedrawOnAllocate]("GI.Gtk.Objects.Widget#g:method:setRedrawOnAllocate"), [setResizeMode]("GI.Gtk.Objects.Container#g:method:setResizeMode"), [setRevealDuration]("GI.Handy.Objects.Flap#g:method:setRevealDuration"), [setRevealFlap]("GI.Handy.Objects.Flap#g:method:setRevealFlap"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSeparator]("GI.Handy.Objects.Flap#g:method:setSeparator"), [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"), [setSwipeToClose]("GI.Handy.Objects.Flap#g:method:setSwipeToClose"), [setSwipeToOpen]("GI.Handy.Objects.Flap#g:method:setSwipeToOpen"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTooltipWindow]("GI.Gtk.Objects.Widget#g:method:setTooltipWindow"), [setTransitionType]("GI.Handy.Objects.Flap#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"), [setVisual]("GI.Gtk.Objects.Widget#g:method:setVisual"), [setWindow]("GI.Gtk.Objects.Widget#g:method:setWindow").

#if defined(ENABLE_OVERLOADING)
    ResolveFlapMethod                       ,
#endif

-- ** getContent #method:getContent#

#if defined(ENABLE_OVERLOADING)
    FlapGetContentMethodInfo                ,
#endif
    flapGetContent                          ,


-- ** getFlap #method:getFlap#

#if defined(ENABLE_OVERLOADING)
    FlapGetFlapMethodInfo                   ,
#endif
    flapGetFlap                             ,


-- ** getFlapPosition #method:getFlapPosition#

#if defined(ENABLE_OVERLOADING)
    FlapGetFlapPositionMethodInfo           ,
#endif
    flapGetFlapPosition                     ,


-- ** getFoldDuration #method:getFoldDuration#

#if defined(ENABLE_OVERLOADING)
    FlapGetFoldDurationMethodInfo           ,
#endif
    flapGetFoldDuration                     ,


-- ** getFoldPolicy #method:getFoldPolicy#

#if defined(ENABLE_OVERLOADING)
    FlapGetFoldPolicyMethodInfo             ,
#endif
    flapGetFoldPolicy                       ,


-- ** getFolded #method:getFolded#

#if defined(ENABLE_OVERLOADING)
    FlapGetFoldedMethodInfo                 ,
#endif
    flapGetFolded                           ,


-- ** getLocked #method:getLocked#

#if defined(ENABLE_OVERLOADING)
    FlapGetLockedMethodInfo                 ,
#endif
    flapGetLocked                           ,


-- ** getModal #method:getModal#

#if defined(ENABLE_OVERLOADING)
    FlapGetModalMethodInfo                  ,
#endif
    flapGetModal                            ,


-- ** getRevealDuration #method:getRevealDuration#

#if defined(ENABLE_OVERLOADING)
    FlapGetRevealDurationMethodInfo         ,
#endif
    flapGetRevealDuration                   ,


-- ** getRevealFlap #method:getRevealFlap#

#if defined(ENABLE_OVERLOADING)
    FlapGetRevealFlapMethodInfo             ,
#endif
    flapGetRevealFlap                       ,


-- ** getRevealProgress #method:getRevealProgress#

#if defined(ENABLE_OVERLOADING)
    FlapGetRevealProgressMethodInfo         ,
#endif
    flapGetRevealProgress                   ,


-- ** getSeparator #method:getSeparator#

#if defined(ENABLE_OVERLOADING)
    FlapGetSeparatorMethodInfo              ,
#endif
    flapGetSeparator                        ,


-- ** getSwipeToClose #method:getSwipeToClose#

#if defined(ENABLE_OVERLOADING)
    FlapGetSwipeToCloseMethodInfo           ,
#endif
    flapGetSwipeToClose                     ,


-- ** getSwipeToOpen #method:getSwipeToOpen#

#if defined(ENABLE_OVERLOADING)
    FlapGetSwipeToOpenMethodInfo            ,
#endif
    flapGetSwipeToOpen                      ,


-- ** getTransitionType #method:getTransitionType#

#if defined(ENABLE_OVERLOADING)
    FlapGetTransitionTypeMethodInfo         ,
#endif
    flapGetTransitionType                   ,


-- ** new #method:new#

    flapNew                                 ,


-- ** setContent #method:setContent#

#if defined(ENABLE_OVERLOADING)
    FlapSetContentMethodInfo                ,
#endif
    flapSetContent                          ,


-- ** setFlap #method:setFlap#

#if defined(ENABLE_OVERLOADING)
    FlapSetFlapMethodInfo                   ,
#endif
    flapSetFlap                             ,


-- ** setFlapPosition #method:setFlapPosition#

#if defined(ENABLE_OVERLOADING)
    FlapSetFlapPositionMethodInfo           ,
#endif
    flapSetFlapPosition                     ,


-- ** setFoldDuration #method:setFoldDuration#

#if defined(ENABLE_OVERLOADING)
    FlapSetFoldDurationMethodInfo           ,
#endif
    flapSetFoldDuration                     ,


-- ** setFoldPolicy #method:setFoldPolicy#

#if defined(ENABLE_OVERLOADING)
    FlapSetFoldPolicyMethodInfo             ,
#endif
    flapSetFoldPolicy                       ,


-- ** setLocked #method:setLocked#

#if defined(ENABLE_OVERLOADING)
    FlapSetLockedMethodInfo                 ,
#endif
    flapSetLocked                           ,


-- ** setModal #method:setModal#

#if defined(ENABLE_OVERLOADING)
    FlapSetModalMethodInfo                  ,
#endif
    flapSetModal                            ,


-- ** setRevealDuration #method:setRevealDuration#

#if defined(ENABLE_OVERLOADING)
    FlapSetRevealDurationMethodInfo         ,
#endif
    flapSetRevealDuration                   ,


-- ** setRevealFlap #method:setRevealFlap#

#if defined(ENABLE_OVERLOADING)
    FlapSetRevealFlapMethodInfo             ,
#endif
    flapSetRevealFlap                       ,


-- ** setSeparator #method:setSeparator#

#if defined(ENABLE_OVERLOADING)
    FlapSetSeparatorMethodInfo              ,
#endif
    flapSetSeparator                        ,


-- ** setSwipeToClose #method:setSwipeToClose#

#if defined(ENABLE_OVERLOADING)
    FlapSetSwipeToCloseMethodInfo           ,
#endif
    flapSetSwipeToClose                     ,


-- ** setSwipeToOpen #method:setSwipeToOpen#

#if defined(ENABLE_OVERLOADING)
    FlapSetSwipeToOpenMethodInfo            ,
#endif
    flapSetSwipeToOpen                      ,


-- ** setTransitionType #method:setTransitionType#

#if defined(ENABLE_OVERLOADING)
    FlapSetTransitionTypeMethodInfo         ,
#endif
    flapSetTransitionType                   ,




 -- * Properties


-- ** content #attr:content#
-- | The content widget.
-- 
-- It\'s always displayed when unfolded, and partially visible
-- when folded.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapContentPropertyInfo                 ,
#endif
    clearFlapContent                        ,
    constructFlapContent                    ,
#if defined(ENABLE_OVERLOADING)
    flapContent                             ,
#endif
    getFlapContent                          ,
    setFlapContent                          ,


-- ** flap #attr:flap#
-- | The flap widget.
-- 
-- It\'s only visible when [property/@flap@/:reveal-progress] is greater than 0.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapFlapPropertyInfo                    ,
#endif
    clearFlapFlap                           ,
    constructFlapFlap                       ,
#if defined(ENABLE_OVERLOADING)
    flapFlap                                ,
#endif
    getFlapFlap                             ,
    setFlapFlap                             ,


-- ** flapPosition #attr:flapPosition#
-- | The flap position.
-- 
-- If @GTK_PACK_START@, the flap is displayed before the content, if
-- @GTK_PACK_END@, it\'s displayed after the content.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapFlapPositionPropertyInfo            ,
#endif
    constructFlapFlapPosition               ,
#if defined(ENABLE_OVERLOADING)
    flapFlapPosition                        ,
#endif
    getFlapFlapPosition                     ,
    setFlapFlapPosition                     ,


-- ** foldDuration #attr:foldDuration#
-- | The fold transition animation duration, in milliseconds.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapFoldDurationPropertyInfo            ,
#endif
    constructFlapFoldDuration               ,
#if defined(ENABLE_OVERLOADING)
    flapFoldDuration                        ,
#endif
    getFlapFoldDuration                     ,
    setFlapFoldDuration                     ,


-- ** foldPolicy #attr:foldPolicy#
-- | The current fold policy.
-- 
-- See [enum/@flapFoldPolicy@/] for available policies.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapFoldPolicyPropertyInfo              ,
#endif
    constructFlapFoldPolicy                 ,
#if defined(ENABLE_OVERLOADING)
    flapFoldPolicy                          ,
#endif
    getFlapFoldPolicy                       ,
    setFlapFoldPolicy                       ,


-- ** folded #attr:folded#
-- | Whether the flap is currently folded.
-- 
-- See [property/@flap@/:fold-policy].
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapFoldedPropertyInfo                  ,
#endif
#if defined(ENABLE_OVERLOADING)
    flapFolded                              ,
#endif
    getFlapFolded                           ,


-- ** locked #attr:locked#
-- | Whether the flap is locked.
-- 
-- If @FALSE@, folding when the flap is revealed automatically closes it, and
-- unfolding it when the flap is not revealed opens it. If @TRUE@,
-- [property/@flap@/:reveal-flap] value never changes on its own.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapLockedPropertyInfo                  ,
#endif
    constructFlapLocked                     ,
#if defined(ENABLE_OVERLOADING)
    flapLocked                              ,
#endif
    getFlapLocked                           ,
    setFlapLocked                           ,


-- ** modal #attr:modal#
-- | Whether the flap is modal.
-- 
-- If @TRUE@, clicking the content widget while flap is revealed, as well as
-- pressing the \<kbd>Esc\<\/kbd> key, will close the flap. If @FALSE@, clicks
-- are passed through to the content widget.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapModalPropertyInfo                   ,
#endif
    constructFlapModal                      ,
#if defined(ENABLE_OVERLOADING)
    flapModal                               ,
#endif
    getFlapModal                            ,
    setFlapModal                            ,


-- ** revealDuration #attr:revealDuration#
-- | The reveal transition animation duration, in milliseconds.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapRevealDurationPropertyInfo          ,
#endif
    constructFlapRevealDuration             ,
#if defined(ENABLE_OVERLOADING)
    flapRevealDuration                      ,
#endif
    getFlapRevealDuration                   ,
    setFlapRevealDuration                   ,


-- ** revealFlap #attr:revealFlap#
-- | Whether the flap widget is revealed.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapRevealFlapPropertyInfo              ,
#endif
    constructFlapRevealFlap                 ,
#if defined(ENABLE_OVERLOADING)
    flapRevealFlap                          ,
#endif
    getFlapRevealFlap                       ,
    setFlapRevealFlap                       ,


-- ** revealProgress #attr:revealProgress#
-- | The current reveal transition progress.
-- 
-- 0 means fully hidden, 1 means fully revealed. See
-- [property/@flap@/:reveal-flap].
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapRevealProgressPropertyInfo          ,
#endif
#if defined(ENABLE_OVERLOADING)
    flapRevealProgress                      ,
#endif
    getFlapRevealProgress                   ,


-- ** separator #attr:separator#
-- | The separator widget.
-- 
-- It\'s displayed between content and flap when there\'s no shadow to display.
-- When exactly it\'s visible depends on the [property/@flap@/:transition-type]
-- value. If @NULL@, no separator will be used.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapSeparatorPropertyInfo               ,
#endif
    clearFlapSeparator                      ,
    constructFlapSeparator                  ,
#if defined(ENABLE_OVERLOADING)
    flapSeparator                           ,
#endif
    getFlapSeparator                        ,
    setFlapSeparator                        ,


-- ** swipeToClose #attr:swipeToClose#
-- | Whether the flap can be closed with a swipe gesture.
-- 
-- The area that can be swiped depends on the [property/@flap@/:transition-type]
-- value.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapSwipeToClosePropertyInfo            ,
#endif
    constructFlapSwipeToClose               ,
#if defined(ENABLE_OVERLOADING)
    flapSwipeToClose                        ,
#endif
    getFlapSwipeToClose                     ,
    setFlapSwipeToClose                     ,


-- ** swipeToOpen #attr:swipeToOpen#
-- | Whether the flap can be opened with a swipe gesture.
-- 
-- The area that can be swiped depends on the [property/@flap@/:transition-type]
-- value.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapSwipeToOpenPropertyInfo             ,
#endif
    constructFlapSwipeToOpen                ,
#if defined(ENABLE_OVERLOADING)
    flapSwipeToOpen                         ,
#endif
    getFlapSwipeToOpen                      ,
    setFlapSwipeToOpen                      ,


-- ** transitionType #attr:transitionType#
-- | the type of animation used for reveal and fold transitions.
-- 
-- [property/@flap@/:flap] is transparent by default, which means the content
-- will be seen through it with @HDY_FLAP_TRANSITION_TYPE_OVER@ transitions;
-- add the @.background@ style class to it if this is unwanted.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    FlapTransitionTypePropertyInfo          ,
#endif
    constructFlapTransitionType             ,
#if defined(ENABLE_OVERLOADING)
    flapTransitionType                      ,
#endif
    getFlapTransitionType                   ,
    setFlapTransitionType                   ,




    ) where

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

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

import 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 Flap = Flap (SP.ManagedPtr Flap)
    deriving (Flap -> Flap -> Bool
(Flap -> Flap -> Bool) -> (Flap -> Flap -> Bool) -> Eq Flap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Flap -> Flap -> Bool
== :: Flap -> Flap -> Bool
$c/= :: Flap -> Flap -> Bool
/= :: Flap -> Flap -> Bool
Eq)

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

foreign import ccall "hdy_flap_get_type"
    c_hdy_flap_get_type :: IO B.Types.GType

instance B.Types.TypedObject Flap where
    glibType :: IO GType
glibType = IO GType
c_hdy_flap_get_type

instance B.Types.GObject Flap

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

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

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

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

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

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

#endif

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

#endif

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

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

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

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

-- | Set the value of the “@content@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #content
-- @
clearFlapContent :: (MonadIO m, IsFlap o) => o -> m ()
clearFlapContent :: forall (m :: * -> *) o. (MonadIO m, IsFlap o) => o -> m ()
clearFlapContent o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"content" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data FlapContentPropertyInfo
instance AttrInfo FlapContentPropertyInfo where
    type AttrAllowedOps FlapContentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint FlapContentPropertyInfo = IsFlap
    type AttrSetTypeConstraint FlapContentPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint FlapContentPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType FlapContentPropertyInfo = Gtk.Widget.Widget
    type AttrGetType FlapContentPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel FlapContentPropertyInfo = "content"
    type AttrOrigin FlapContentPropertyInfo = Flap
    attrGet = getFlapContent
    attrSet = setFlapContent
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructFlapContent
    attrClear = clearFlapContent
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Flap.content"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.4/docs/GI-Handy-Objects-Flap.html#g:attr:content"
        })
#endif

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

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

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

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

-- | Set the value of the “@flap@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #flap
-- @
clearFlapFlap :: (MonadIO m, IsFlap o) => o -> m ()
clearFlapFlap :: forall (m :: * -> *) o. (MonadIO m, IsFlap o) => o -> m ()
clearFlapFlap o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"flap" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data FlapFlapPropertyInfo
instance AttrInfo FlapFlapPropertyInfo where
    type AttrAllowedOps FlapFlapPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint FlapFlapPropertyInfo = IsFlap
    type AttrSetTypeConstraint FlapFlapPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint FlapFlapPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType FlapFlapPropertyInfo = Gtk.Widget.Widget
    type AttrGetType FlapFlapPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel FlapFlapPropertyInfo = "flap"
    type AttrOrigin FlapFlapPropertyInfo = Flap
    attrGet = getFlapFlap
    attrSet = setFlapFlap
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructFlapFlap
    attrClear = clearFlapFlap
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Flap.flap"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.4/docs/GI-Handy-Objects-Flap.html#g:attr:flap"
        })
#endif

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

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

-- | Set the value of the “@flap-position@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' flap [ #flapPosition 'Data.GI.Base.Attributes.:=' value ]
-- @
setFlapFlapPosition :: (MonadIO m, IsFlap o) => o -> Gtk.Enums.PackType -> m ()
setFlapFlapPosition :: forall (m :: * -> *) o.
(MonadIO m, IsFlap o) =>
o -> PackType -> m ()
setFlapFlapPosition o
obj PackType
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> PackType -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"flap-position" PackType
val

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

#if defined(ENABLE_OVERLOADING)
data FlapFlapPositionPropertyInfo
instance AttrInfo FlapFlapPositionPropertyInfo where
    type AttrAllowedOps FlapFlapPositionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FlapFlapPositionPropertyInfo = IsFlap
    type AttrSetTypeConstraint FlapFlapPositionPropertyInfo = (~) Gtk.Enums.PackType
    type AttrTransferTypeConstraint FlapFlapPositionPropertyInfo = (~) Gtk.Enums.PackType
    type AttrTransferType FlapFlapPositionPropertyInfo = Gtk.Enums.PackType
    type AttrGetType FlapFlapPositionPropertyInfo = Gtk.Enums.PackType
    type AttrLabel FlapFlapPositionPropertyInfo = "flap-position"
    type AttrOrigin FlapFlapPositionPropertyInfo = Flap
    attrGet = getFlapFlapPosition
    attrSet = setFlapFlapPosition
    attrTransfer _ v = do
        return v
    attrConstruct = constructFlapFlapPosition
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Flap.flapPosition"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.4/docs/GI-Handy-Objects-Flap.html#g:attr:flapPosition"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data FlapFoldDurationPropertyInfo
instance AttrInfo FlapFoldDurationPropertyInfo where
    type AttrAllowedOps FlapFoldDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FlapFoldDurationPropertyInfo = IsFlap
    type AttrSetTypeConstraint FlapFoldDurationPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint FlapFoldDurationPropertyInfo = (~) Word32
    type AttrTransferType FlapFoldDurationPropertyInfo = Word32
    type AttrGetType FlapFoldDurationPropertyInfo = Word32
    type AttrLabel FlapFoldDurationPropertyInfo = "fold-duration"
    type AttrOrigin FlapFoldDurationPropertyInfo = Flap
    attrGet = getFlapFoldDuration
    attrSet = setFlapFoldDuration
    attrTransfer _ v = do
        return v
    attrConstruct = constructFlapFoldDuration
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Flap.foldDuration"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.4/docs/GI-Handy-Objects-Flap.html#g:attr:foldDuration"
        })
#endif

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

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

-- | Set the value of the “@fold-policy@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' flap [ #foldPolicy 'Data.GI.Base.Attributes.:=' value ]
-- @
setFlapFoldPolicy :: (MonadIO m, IsFlap o) => o -> Handy.Enums.FlapFoldPolicy -> m ()
setFlapFoldPolicy :: forall (m :: * -> *) o.
(MonadIO m, IsFlap o) =>
o -> FlapFoldPolicy -> m ()
setFlapFoldPolicy o
obj FlapFoldPolicy
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> FlapFoldPolicy -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"fold-policy" FlapFoldPolicy
val

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

#if defined(ENABLE_OVERLOADING)
data FlapFoldPolicyPropertyInfo
instance AttrInfo FlapFoldPolicyPropertyInfo where
    type AttrAllowedOps FlapFoldPolicyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FlapFoldPolicyPropertyInfo = IsFlap
    type AttrSetTypeConstraint FlapFoldPolicyPropertyInfo = (~) Handy.Enums.FlapFoldPolicy
    type AttrTransferTypeConstraint FlapFoldPolicyPropertyInfo = (~) Handy.Enums.FlapFoldPolicy
    type AttrTransferType FlapFoldPolicyPropertyInfo = Handy.Enums.FlapFoldPolicy
    type AttrGetType FlapFoldPolicyPropertyInfo = Handy.Enums.FlapFoldPolicy
    type AttrLabel FlapFoldPolicyPropertyInfo = "fold-policy"
    type AttrOrigin FlapFoldPolicyPropertyInfo = Flap
    attrGet = getFlapFoldPolicy
    attrSet = setFlapFoldPolicy
    attrTransfer _ v = do
        return v
    attrConstruct = constructFlapFoldPolicy
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Flap.foldPolicy"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.4/docs/GI-Handy-Objects-Flap.html#g:attr:foldPolicy"
        })
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data FlapRevealFlapPropertyInfo
instance AttrInfo FlapRevealFlapPropertyInfo where
    type AttrAllowedOps FlapRevealFlapPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FlapRevealFlapPropertyInfo = IsFlap
    type AttrSetTypeConstraint FlapRevealFlapPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint FlapRevealFlapPropertyInfo = (~) Bool
    type AttrTransferType FlapRevealFlapPropertyInfo = Bool
    type AttrGetType FlapRevealFlapPropertyInfo = Bool
    type AttrLabel FlapRevealFlapPropertyInfo = "reveal-flap"
    type AttrOrigin FlapRevealFlapPropertyInfo = Flap
    attrGet = getFlapRevealFlap
    attrSet = setFlapRevealFlap
    attrTransfer _ v = do
        return v
    attrConstruct = constructFlapRevealFlap
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Flap.revealFlap"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.4/docs/GI-Handy-Objects-Flap.html#g:attr:revealFlap"
        })
#endif

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

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

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

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

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

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

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

-- | Set the value of the “@separator@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #separator
-- @
clearFlapSeparator :: (MonadIO m, IsFlap o) => o -> m ()
clearFlapSeparator :: forall (m :: * -> *) o. (MonadIO m, IsFlap o) => o -> m ()
clearFlapSeparator o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"separator" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data FlapSeparatorPropertyInfo
instance AttrInfo FlapSeparatorPropertyInfo where
    type AttrAllowedOps FlapSeparatorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint FlapSeparatorPropertyInfo = IsFlap
    type AttrSetTypeConstraint FlapSeparatorPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint FlapSeparatorPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType FlapSeparatorPropertyInfo = Gtk.Widget.Widget
    type AttrGetType FlapSeparatorPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel FlapSeparatorPropertyInfo = "separator"
    type AttrOrigin FlapSeparatorPropertyInfo = Flap
    attrGet = getFlapSeparator
    attrSet = setFlapSeparator
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructFlapSeparator
    attrClear = clearFlapSeparator
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Flap.separator"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.4/docs/GI-Handy-Objects-Flap.html#g:attr:separator"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data FlapSwipeToClosePropertyInfo
instance AttrInfo FlapSwipeToClosePropertyInfo where
    type AttrAllowedOps FlapSwipeToClosePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FlapSwipeToClosePropertyInfo = IsFlap
    type AttrSetTypeConstraint FlapSwipeToClosePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint FlapSwipeToClosePropertyInfo = (~) Bool
    type AttrTransferType FlapSwipeToClosePropertyInfo = Bool
    type AttrGetType FlapSwipeToClosePropertyInfo = Bool
    type AttrLabel FlapSwipeToClosePropertyInfo = "swipe-to-close"
    type AttrOrigin FlapSwipeToClosePropertyInfo = Flap
    attrGet = getFlapSwipeToClose
    attrSet = setFlapSwipeToClose
    attrTransfer _ v = do
        return v
    attrConstruct = constructFlapSwipeToClose
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Flap.swipeToClose"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.4/docs/GI-Handy-Objects-Flap.html#g:attr:swipeToClose"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data FlapSwipeToOpenPropertyInfo
instance AttrInfo FlapSwipeToOpenPropertyInfo where
    type AttrAllowedOps FlapSwipeToOpenPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FlapSwipeToOpenPropertyInfo = IsFlap
    type AttrSetTypeConstraint FlapSwipeToOpenPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint FlapSwipeToOpenPropertyInfo = (~) Bool
    type AttrTransferType FlapSwipeToOpenPropertyInfo = Bool
    type AttrGetType FlapSwipeToOpenPropertyInfo = Bool
    type AttrLabel FlapSwipeToOpenPropertyInfo = "swipe-to-open"
    type AttrOrigin FlapSwipeToOpenPropertyInfo = Flap
    attrGet = getFlapSwipeToOpen
    attrSet = setFlapSwipeToOpen
    attrTransfer _ v = do
        return v
    attrConstruct = constructFlapSwipeToOpen
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Flap.swipeToOpen"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.4/docs/GI-Handy-Objects-Flap.html#g:attr:swipeToOpen"
        })
#endif

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

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

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Flap
type instance O.AttributeList Flap = FlapAttributeList
type FlapAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("content", FlapContentPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("flap", FlapFlapPropertyInfo), '("flapPosition", FlapFlapPositionPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("foldDuration", FlapFoldDurationPropertyInfo), '("foldPolicy", FlapFoldPolicyPropertyInfo), '("folded", FlapFoldedPropertyInfo), '("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), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("locked", FlapLockedPropertyInfo), '("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), '("modal", FlapModalPropertyInfo), '("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), '("revealDuration", FlapRevealDurationPropertyInfo), '("revealFlap", FlapRevealFlapPropertyInfo), '("revealProgress", FlapRevealProgressPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("separator", FlapSeparatorPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("swipeToClose", FlapSwipeToClosePropertyInfo), '("swipeToOpen", FlapSwipeToOpenPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("transitionType", FlapTransitionTypePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
flapContent :: AttrLabelProxy "content"
flapContent = AttrLabelProxy

flapFlap :: AttrLabelProxy "flap"
flapFlap = AttrLabelProxy

flapFlapPosition :: AttrLabelProxy "flapPosition"
flapFlapPosition = AttrLabelProxy

flapFoldDuration :: AttrLabelProxy "foldDuration"
flapFoldDuration = AttrLabelProxy

flapFoldPolicy :: AttrLabelProxy "foldPolicy"
flapFoldPolicy = AttrLabelProxy

flapFolded :: AttrLabelProxy "folded"
flapFolded = AttrLabelProxy

flapLocked :: AttrLabelProxy "locked"
flapLocked = AttrLabelProxy

flapModal :: AttrLabelProxy "modal"
flapModal = AttrLabelProxy

flapRevealDuration :: AttrLabelProxy "revealDuration"
flapRevealDuration = AttrLabelProxy

flapRevealFlap :: AttrLabelProxy "revealFlap"
flapRevealFlap = AttrLabelProxy

flapRevealProgress :: AttrLabelProxy "revealProgress"
flapRevealProgress = AttrLabelProxy

flapSeparator :: AttrLabelProxy "separator"
flapSeparator = AttrLabelProxy

flapSwipeToClose :: AttrLabelProxy "swipeToClose"
flapSwipeToClose = AttrLabelProxy

flapSwipeToOpen :: AttrLabelProxy "swipeToOpen"
flapSwipeToOpen = AttrLabelProxy

flapTransitionType :: AttrLabelProxy "transitionType"
flapTransitionType = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Flap = FlapSignalList
type FlapSignalList = ('[ '("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, DK.Type)])

#endif

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

foreign import ccall "hdy_flap_new" hdy_flap_new :: 
    IO (Ptr Flap)

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

#if defined(ENABLE_OVERLOADING)
#endif

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

-- | Gets the content widget for /@self@/
-- 
-- /Since: 1.2/
flapGetContent ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the content widget for /@self@/
flapGetContent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m (Maybe Widget)
flapGetContent a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr Flap -> IO (Ptr Widget)
hdy_flap_get_content Ptr Flap
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

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

-- | Gets the flap widget for /@self@/
-- 
-- /Since: 1.2/
flapGetFlap ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the flap widget for /@self@/
flapGetFlap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m (Maybe Widget)
flapGetFlap a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr Flap -> IO (Ptr Widget)
hdy_flap_get_flap Ptr Flap
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

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

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

-- | Gets the flap position for /@self@/.
-- 
-- /Since: 1.2/
flapGetFlapPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m Gtk.Enums.PackType
    -- ^ __Returns:__ the flap position for /@self@/
flapGetFlapPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m PackType
flapGetFlapPosition a
self = IO PackType -> m PackType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PackType -> m PackType) -> IO PackType -> m PackType
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Flap -> IO CUInt
hdy_flap_get_flap_position Ptr Flap
self'
    let result' :: PackType
result' = (Int -> PackType
forall a. Enum a => Int -> a
toEnum (Int -> PackType) -> (CUInt -> Int) -> CUInt -> PackType
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
    PackType -> IO PackType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PackType
result'

#if defined(ENABLE_OVERLOADING)
data FlapGetFlapPositionMethodInfo
instance (signature ~ (m Gtk.Enums.PackType), MonadIO m, IsFlap a) => O.OverloadedMethod FlapGetFlapPositionMethodInfo a signature where
    overloadedMethod = flapGetFlapPosition

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


#endif

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

-- | Gets the amount of time that fold transitions will take.
-- 
-- /Since: 1.2/
flapGetFoldDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m Word32
    -- ^ __Returns:__ the fold transition duration, in milliseconds
flapGetFoldDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m Word32
flapGetFoldDuration a
self = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Flap -> IO Word32
hdy_flap_get_fold_duration Ptr Flap
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data FlapGetFoldDurationMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsFlap a) => O.OverloadedMethod FlapGetFoldDurationMethodInfo a signature where
    overloadedMethod = flapGetFoldDuration

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


#endif

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

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

-- | Gets the current fold policy of /@self@/.
-- 
-- /Since: 1.2/
flapGetFoldPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m Handy.Enums.FlapFoldPolicy
    -- ^ __Returns:__ the current fold policy of /@self@/
flapGetFoldPolicy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m FlapFoldPolicy
flapGetFoldPolicy a
self = IO FlapFoldPolicy -> m FlapFoldPolicy
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlapFoldPolicy -> m FlapFoldPolicy)
-> IO FlapFoldPolicy -> m FlapFoldPolicy
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Flap -> IO CUInt
hdy_flap_get_fold_policy Ptr Flap
self'
    let result' :: FlapFoldPolicy
result' = (Int -> FlapFoldPolicy
forall a. Enum a => Int -> a
toEnum (Int -> FlapFoldPolicy)
-> (CUInt -> Int) -> CUInt -> FlapFoldPolicy
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
    FlapFoldPolicy -> IO FlapFoldPolicy
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FlapFoldPolicy
result'

#if defined(ENABLE_OVERLOADING)
data FlapGetFoldPolicyMethodInfo
instance (signature ~ (m Handy.Enums.FlapFoldPolicy), MonadIO m, IsFlap a) => O.OverloadedMethod FlapGetFoldPolicyMethodInfo a signature where
    overloadedMethod = flapGetFoldPolicy

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


#endif

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

-- | Gets whether /@self@/ is currently folded.
-- 
-- /Since: 1.2/
flapGetFolded ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m Bool
    -- ^ __Returns:__ @TRUE@ if /@self@/ is currently folded
flapGetFolded :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m Bool
flapGetFolded a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Flap -> IO CInt
hdy_flap_get_folded Ptr Flap
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FlapGetFoldedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFlap a) => O.OverloadedMethod FlapGetFoldedMethodInfo a signature where
    overloadedMethod = flapGetFolded

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


#endif

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

-- | Gets whether /@self@/ is locked.
-- 
-- /Since: 1.2/
flapGetLocked ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ is locked
flapGetLocked :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m Bool
flapGetLocked a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Flap -> IO CInt
hdy_flap_get_locked Ptr Flap
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FlapGetLockedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFlap a) => O.OverloadedMethod FlapGetLockedMethodInfo a signature where
    overloadedMethod = flapGetLocked

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


#endif

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

-- | Gets whether the /@self@/ is modal.
-- 
-- /Since: 1.2/
flapGetModal ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ is modal
flapGetModal :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m Bool
flapGetModal a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Flap -> IO CInt
hdy_flap_get_modal Ptr Flap
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FlapGetModalMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFlap a) => O.OverloadedMethod FlapGetModalMethodInfo a signature where
    overloadedMethod = flapGetModal

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


#endif

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

-- | Gets the amount of time that reveal transitions will take.
-- 
-- /Since: 1.2/
flapGetRevealDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m Word32
    -- ^ __Returns:__ the reveal transition duration, in milliseconds
flapGetRevealDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m Word32
flapGetRevealDuration a
self = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Flap -> IO Word32
hdy_flap_get_reveal_duration Ptr Flap
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data FlapGetRevealDurationMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsFlap a) => O.OverloadedMethod FlapGetRevealDurationMethodInfo a signature where
    overloadedMethod = flapGetRevealDuration

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


#endif

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

-- | Gets whether the flap widget is revealed for /@self@/.
-- 
-- /Since: 1.2/
flapGetRevealFlap ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m Bool
    -- ^ __Returns:__ whether flap widget is revealed
flapGetRevealFlap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m Bool
flapGetRevealFlap a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Flap -> IO CInt
hdy_flap_get_reveal_flap Ptr Flap
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FlapGetRevealFlapMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFlap a) => O.OverloadedMethod FlapGetRevealFlapMethodInfo a signature where
    overloadedMethod = flapGetRevealFlap

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


#endif

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

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

-- | Gets the current reveal transition progress for /@self@/.
-- 
-- /Since: 1.2/
flapGetRevealProgress ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m Double
    -- ^ __Returns:__ the current reveal progress for /@self@/
flapGetRevealProgress :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m Double
flapGetRevealProgress a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr Flap -> IO CDouble
hdy_flap_get_reveal_progress Ptr Flap
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data FlapGetRevealProgressMethodInfo
instance (signature ~ (m Double), MonadIO m, IsFlap a) => O.OverloadedMethod FlapGetRevealProgressMethodInfo a signature where
    overloadedMethod = flapGetRevealProgress

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


#endif

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

-- | Gets the separator widget for /@self@/.
-- 
-- /Since: 1.2/
flapGetSeparator ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the separator widget for /@self@/
flapGetSeparator :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m (Maybe Widget)
flapGetSeparator a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr Flap -> IO (Ptr Widget)
hdy_flap_get_separator Ptr Flap
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

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

-- | Gets whether /@self@/ can be closed with a swipe gesture.
-- 
-- /Since: 1.2/
flapGetSwipeToClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m Bool
    -- ^ __Returns:__ @TRUE@ if /@self@/ can be closed with a swipe gesture
flapGetSwipeToClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m Bool
flapGetSwipeToClose a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Flap -> IO CInt
hdy_flap_get_swipe_to_close Ptr Flap
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FlapGetSwipeToCloseMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFlap a) => O.OverloadedMethod FlapGetSwipeToCloseMethodInfo a signature where
    overloadedMethod = flapGetSwipeToClose

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


#endif

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

-- | Gets whether /@self@/ can be opened with a swipe gesture.
-- 
-- /Since: 1.2/
flapGetSwipeToOpen ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m Bool
    -- ^ __Returns:__ @TRUE@ if /@self@/ can be opened with a swipe gesture
flapGetSwipeToOpen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m Bool
flapGetSwipeToOpen a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Flap -> IO CInt
hdy_flap_get_swipe_to_open Ptr Flap
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FlapGetSwipeToOpenMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFlap a) => O.OverloadedMethod FlapGetSwipeToOpenMethodInfo a signature where
    overloadedMethod = flapGetSwipeToOpen

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


#endif

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

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

-- | Gets the type of animation used for reveal and fold transitions in /@self@/.
-- 
-- /Since: 1.2/
flapGetTransitionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> m Handy.Enums.FlapTransitionType
    -- ^ __Returns:__ the current transition type of /@self@/
flapGetTransitionType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> m FlapTransitionType
flapGetTransitionType a
self = IO FlapTransitionType -> m FlapTransitionType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlapTransitionType -> m FlapTransitionType)
-> IO FlapTransitionType -> m FlapTransitionType
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Flap -> IO CUInt
hdy_flap_get_transition_type Ptr Flap
self'
    let result' :: FlapTransitionType
result' = (Int -> FlapTransitionType
forall a. Enum a => Int -> a
toEnum (Int -> FlapTransitionType)
-> (CUInt -> Int) -> CUInt -> FlapTransitionType
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
    FlapTransitionType -> IO FlapTransitionType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FlapTransitionType
result'

#if defined(ENABLE_OVERLOADING)
data FlapGetTransitionTypeMethodInfo
instance (signature ~ (m Handy.Enums.FlapTransitionType), MonadIO m, IsFlap a) => O.OverloadedMethod FlapGetTransitionTypeMethodInfo a signature where
    overloadedMethod = flapGetTransitionType

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


#endif

-- method Flap::set_content
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Flap" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a flap" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "content"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the content widget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the content widget for /@self@/.
-- 
-- It is always displayed when unfolded, and partially visible when folded.
-- 
-- /Since: 1.2/
flapSetContent ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a flap
    -> Maybe (b)
    -- ^ /@content@/: the content widget
    -> m ()
flapSetContent :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFlap a, IsWidget b) =>
a -> Maybe b -> m ()
flapSetContent a
self Maybe b
content = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeContent <- case Maybe b
content of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jContent -> do
            Ptr Widget
jContent' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jContent
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jContent'
    Ptr Flap -> Ptr Widget -> IO ()
hdy_flap_set_content Ptr Flap
self' Ptr Widget
maybeContent
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
content b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetContentMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsFlap a, Gtk.Widget.IsWidget b) => O.OverloadedMethod FlapSetContentMethodInfo a signature where
    overloadedMethod = flapSetContent

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


#endif

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

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

-- | Sets the flap widget for /@self@/.
-- 
-- /Since: 1.2/
flapSetFlap ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a flap
    -> Maybe (b)
    -- ^ /@flap@/: the flap widget
    -> m ()
flapSetFlap :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFlap a, IsWidget b) =>
a -> Maybe b -> m ()
flapSetFlap a
self Maybe b
flap = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeFlap <- case Maybe b
flap of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jFlap -> do
            Ptr Widget
jFlap' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jFlap
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jFlap'
    Ptr Flap -> Ptr Widget -> IO ()
hdy_flap_set_flap Ptr Flap
self' Ptr Widget
maybeFlap
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
flap b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetFlapMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsFlap a, Gtk.Widget.IsWidget b) => O.OverloadedMethod FlapSetFlapMethodInfo a signature where
    overloadedMethod = flapSetFlap

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


#endif

-- method Flap::set_flap_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Flap" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a flap" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PackType" }
--           , 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_flap_set_flap_position" hdy_flap_set_flap_position :: 
    Ptr Flap ->                             -- self : TInterface (Name {namespace = "Handy", name = "Flap"})
    CUInt ->                                -- position : TInterface (Name {namespace = "Gtk", name = "PackType"})
    IO ()

-- | Sets the flap position for /@self@/.
-- 
-- /Since: 1.2/
flapSetFlapPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> Gtk.Enums.PackType
    -- ^ /@position@/: the new value
    -> m ()
flapSetFlapPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> PackType -> m ()
flapSetFlapPosition a
self PackType
position = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let position' :: CUInt
position' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PackType -> Int) -> PackType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackType -> Int
forall a. Enum a => a -> Int
fromEnum) PackType
position
    Ptr Flap -> CUInt -> IO ()
hdy_flap_set_flap_position Ptr Flap
self' CUInt
position'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetFlapPositionMethodInfo
instance (signature ~ (Gtk.Enums.PackType -> m ()), MonadIO m, IsFlap a) => O.OverloadedMethod FlapSetFlapPositionMethodInfo a signature where
    overloadedMethod = flapSetFlapPosition

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


#endif

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

-- | Sets the duration that fold transitions will take.
-- 
-- /Since: 1.2/
flapSetFoldDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> Word32
    -- ^ /@duration@/: the new duration, in milliseconds
    -> m ()
flapSetFoldDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> Word32 -> m ()
flapSetFoldDuration a
self Word32
duration = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Flap -> Word32 -> IO ()
hdy_flap_set_fold_duration Ptr Flap
self' Word32
duration
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetFoldDurationMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsFlap a) => O.OverloadedMethod FlapSetFoldDurationMethodInfo a signature where
    overloadedMethod = flapSetFoldDuration

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


#endif

-- method Flap::set_fold_policy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Flap" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a flap" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "policy"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "FlapFoldPolicy" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a fold policy" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_flap_set_fold_policy" hdy_flap_set_fold_policy :: 
    Ptr Flap ->                             -- self : TInterface (Name {namespace = "Handy", name = "Flap"})
    CUInt ->                                -- policy : TInterface (Name {namespace = "Handy", name = "FlapFoldPolicy"})
    IO ()

-- | Sets the current fold policy for /@self@/.
-- 
-- /Since: 1.2/
flapSetFoldPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> Handy.Enums.FlapFoldPolicy
    -- ^ /@policy@/: a fold policy
    -> m ()
flapSetFoldPolicy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> FlapFoldPolicy -> m ()
flapSetFoldPolicy a
self FlapFoldPolicy
policy = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let policy' :: CUInt
policy' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (FlapFoldPolicy -> Int) -> FlapFoldPolicy -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FlapFoldPolicy -> Int
forall a. Enum a => a -> Int
fromEnum) FlapFoldPolicy
policy
    Ptr Flap -> CUInt -> IO ()
hdy_flap_set_fold_policy Ptr Flap
self' CUInt
policy'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetFoldPolicyMethodInfo
instance (signature ~ (Handy.Enums.FlapFoldPolicy -> m ()), MonadIO m, IsFlap a) => O.OverloadedMethod FlapSetFoldPolicyMethodInfo a signature where
    overloadedMethod = flapSetFoldPolicy

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


#endif

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

-- | Sets whether /@self@/ is locked.
-- 
-- If @FALSE@, folding /@self@/ when the flap is revealed automatically closes it,
-- and unfolding it when the flap is not revealed opens it. If @TRUE@,
-- [property/@flap@/:reveal-flap] value never changes on its own.
-- 
-- /Since: 1.2/
flapSetLocked ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> Bool
    -- ^ /@locked@/: the new value
    -> m ()
flapSetLocked :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> Bool -> m ()
flapSetLocked a
self Bool
locked = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let locked' :: CInt
locked' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
locked
    Ptr Flap -> CInt -> IO ()
hdy_flap_set_locked Ptr Flap
self' CInt
locked'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetLockedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsFlap a) => O.OverloadedMethod FlapSetLockedMethodInfo a signature where
    overloadedMethod = flapSetLocked

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


#endif

-- method Flap::set_modal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Flap" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a flap" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modal"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether @self can be closed with a click"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether the /@self@/ can be closed with a click.
-- 
-- If /@modal@/ is @TRUE@, clicking the content widget while flap is revealed, or
-- pressing the \<kbd>Esc\<\/kbd> key, will close the flap. If @FALSE@, clicks are
-- passed through to the content widget.
-- 
-- /Since: 1.2/
flapSetModal ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> Bool
    -- ^ /@modal@/: whether /@self@/ can be closed with a click
    -> m ()
flapSetModal :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> Bool -> m ()
flapSetModal a
self Bool
modal = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let modal' :: CInt
modal' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
modal
    Ptr Flap -> CInt -> IO ()
hdy_flap_set_modal Ptr Flap
self' CInt
modal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetModalMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsFlap a) => O.OverloadedMethod FlapSetModalMethodInfo a signature where
    overloadedMethod = flapSetModal

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


#endif

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

-- | Sets the duration that reveal transitions in /@self@/ will take.
-- 
-- /Since: 1.2/
flapSetRevealDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> Word32
    -- ^ /@duration@/: the new duration, in milliseconds
    -> m ()
flapSetRevealDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> Word32 -> m ()
flapSetRevealDuration a
self Word32
duration = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Flap -> Word32 -> IO ()
hdy_flap_set_reveal_duration Ptr Flap
self' Word32
duration
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetRevealDurationMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsFlap a) => O.OverloadedMethod FlapSetRevealDurationMethodInfo a signature where
    overloadedMethod = flapSetRevealDuration

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


#endif

-- method Flap::set_reveal_flap
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Flap" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a flap" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "reveal_flap"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "`TRUE` to reveal the flap widget, `FALSE` otherwise"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether the flap widget is revealed for /@self@/.
-- 
-- /Since: 1.2/
flapSetRevealFlap ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> Bool
    -- ^ /@revealFlap@/: @TRUE@ to reveal the flap widget, @FALSE@ otherwise
    -> m ()
flapSetRevealFlap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> Bool -> m ()
flapSetRevealFlap a
self Bool
revealFlap = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let revealFlap' :: CInt
revealFlap' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
revealFlap
    Ptr Flap -> CInt -> IO ()
hdy_flap_set_reveal_flap Ptr Flap
self' CInt
revealFlap'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetRevealFlapMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsFlap a) => O.OverloadedMethod FlapSetRevealFlapMethodInfo a signature where
    overloadedMethod = flapSetRevealFlap

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


#endif

-- method Flap::set_separator
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Flap" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a flap" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "separator"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the separator widget"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the separator widget for /@self@/.
-- 
-- /Since: 1.2/
flapSetSeparator ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a flap
    -> Maybe (b)
    -- ^ /@separator@/: the separator widget
    -> m ()
flapSetSeparator :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFlap a, IsWidget b) =>
a -> Maybe b -> m ()
flapSetSeparator a
self Maybe b
separator = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeSeparator <- case Maybe b
separator of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jSeparator -> do
            Ptr Widget
jSeparator' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSeparator
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jSeparator'
    Ptr Flap -> Ptr Widget -> IO ()
hdy_flap_set_separator Ptr Flap
self' Ptr Widget
maybeSeparator
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
separator b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetSeparatorMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsFlap a, Gtk.Widget.IsWidget b) => O.OverloadedMethod FlapSetSeparatorMethodInfo a signature where
    overloadedMethod = flapSetSeparator

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


#endif

-- method Flap::set_swipe_to_close
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Flap" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a flap" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "swipe_to_close"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether @self can be closed with a swipe gesture"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether /@self@/ can be closed with a swipe gesture.
-- 
-- The area that can be swiped depends on the [property/@flap@/:transition-type] value.
-- 
-- /Since: 1.2/
flapSetSwipeToClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> Bool
    -- ^ /@swipeToClose@/: whether /@self@/ can be closed with a swipe gesture
    -> m ()
flapSetSwipeToClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> Bool -> m ()
flapSetSwipeToClose a
self Bool
swipeToClose = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let swipeToClose' :: CInt
swipeToClose' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
swipeToClose
    Ptr Flap -> CInt -> IO ()
hdy_flap_set_swipe_to_close Ptr Flap
self' CInt
swipeToClose'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetSwipeToCloseMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsFlap a) => O.OverloadedMethod FlapSetSwipeToCloseMethodInfo a signature where
    overloadedMethod = flapSetSwipeToClose

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


#endif

-- method Flap::set_swipe_to_open
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Handy" , name = "Flap" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a flap" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "swipe_to_open"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether @self can be opened with a swipe gesture"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether /@self@/ can be opened with a swipe gesture.
-- 
-- The area that can be swiped depends on the [property/@flap@/:transition-type]
-- value.
-- 
-- /Since: 1.2/
flapSetSwipeToOpen ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> Bool
    -- ^ /@swipeToOpen@/: whether /@self@/ can be opened with a swipe gesture
    -> m ()
flapSetSwipeToOpen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> Bool -> m ()
flapSetSwipeToOpen a
self Bool
swipeToOpen = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let swipeToOpen' :: CInt
swipeToOpen' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
swipeToOpen
    Ptr Flap -> CInt -> IO ()
hdy_flap_set_swipe_to_open Ptr Flap
self' CInt
swipeToOpen'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetSwipeToOpenMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsFlap a) => O.OverloadedMethod FlapSetSwipeToOpenMethodInfo a signature where
    overloadedMethod = flapSetSwipeToOpen

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


#endif

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

-- | Sets the type of animation used for reveal and fold transitions in /@self@/.
-- 
-- /Since: 1.2/
flapSetTransitionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlap a) =>
    a
    -- ^ /@self@/: a flap
    -> Handy.Enums.FlapTransitionType
    -- ^ /@transitionType@/: the new transition type
    -> m ()
flapSetTransitionType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFlap a) =>
a -> FlapTransitionType -> m ()
flapSetTransitionType a
self FlapTransitionType
transitionType = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Flap
self' <- a -> IO (Ptr Flap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let transitionType' :: CUInt
transitionType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (FlapTransitionType -> Int) -> FlapTransitionType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FlapTransitionType -> Int
forall a. Enum a => a -> Int
fromEnum) FlapTransitionType
transitionType
    Ptr Flap -> CUInt -> IO ()
hdy_flap_set_transition_type Ptr Flap
self' CUInt
transitionType'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlapSetTransitionTypeMethodInfo
instance (signature ~ (Handy.Enums.FlapTransitionType -> m ()), MonadIO m, IsFlap a) => O.OverloadedMethod FlapSetTransitionTypeMethodInfo a signature where
    overloadedMethod = flapSetTransitionType

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


#endif