{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A single child container with a popover.
-- 
-- You should use @GtkPopoverBin@ whenever you need to present a t'GI.Gtk.Objects.Popover.Popover'
-- to the user.
-- 
-- == Actions
-- 
-- @GtkPopoverBin@ defines the @menu.popup@ action, which can be activated
-- to present the popover to the user.
-- 
-- == CSS nodes
-- 
-- @GtkPopoverBin@ has a single CSS node with the name @popoverbin@.
-- 
-- /Since: 4.22/

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

module GI.Gtk.Objects.PopoverBin
    ( 

-- * Exported types
    PopoverBin(..)                          ,
    IsPopoverBin                            ,
    toPopoverBin                            ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [announce]("GI.Gtk.Interfaces.Accessible#g:method:announce"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [popdown]("GI.Gtk.Objects.PopoverBin#g:method:popdown"), [popup]("GI.Gtk.Objects.PopoverBin#g:method:popup"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updatePlatformState]("GI.Gtk.Interfaces.Accessible#g:method:updatePlatformState"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleId]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleId"), [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBaseline]("GI.Gtk.Objects.Widget#g:method:getBaseline"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChild]("GI.Gtk.Objects.PopoverBin#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [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"), [getHandleInput]("GI.Gtk.Objects.PopoverBin#g:method:getHandleInput"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getLimitEvents]("GI.Gtk.Objects.Widget#g:method:getLimitEvents"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getMenuModel]("GI.Gtk.Objects.PopoverBin#g:method:getMenuModel"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPopover]("GI.Gtk.Objects.PopoverBin#g:method:getPopover"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
-- 
-- ==== Setters
-- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChild]("GI.Gtk.Objects.PopoverBin#g:method:setChild"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHandleInput]("GI.Gtk.Objects.PopoverBin#g:method:setHandleInput"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setLimitEvents]("GI.Gtk.Objects.Widget#g:method:setLimitEvents"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMenuModel]("GI.Gtk.Objects.PopoverBin#g:method:setMenuModel"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setPopover]("GI.Gtk.Objects.PopoverBin#g:method:setPopover"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [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").

#if defined(ENABLE_OVERLOADING)
    ResolvePopoverBinMethod                 ,
#endif

-- ** getChild #method:getChild#

#if defined(ENABLE_OVERLOADING)
    PopoverBinGetChildMethodInfo            ,
#endif
    popoverBinGetChild                      ,


-- ** getHandleInput #method:getHandleInput#

#if defined(ENABLE_OVERLOADING)
    PopoverBinGetHandleInputMethodInfo      ,
#endif
    popoverBinGetHandleInput                ,


-- ** getMenuModel #method:getMenuModel#

#if defined(ENABLE_OVERLOADING)
    PopoverBinGetMenuModelMethodInfo        ,
#endif
    popoverBinGetMenuModel                  ,


-- ** getPopover #method:getPopover#

#if defined(ENABLE_OVERLOADING)
    PopoverBinGetPopoverMethodInfo          ,
#endif
    popoverBinGetPopover                    ,


-- ** new #method:new#

    popoverBinNew                           ,


-- ** popdown #method:popdown#

#if defined(ENABLE_OVERLOADING)
    PopoverBinPopdownMethodInfo             ,
#endif
    popoverBinPopdown                       ,


-- ** popup #method:popup#

#if defined(ENABLE_OVERLOADING)
    PopoverBinPopupMethodInfo               ,
#endif
    popoverBinPopup                         ,


-- ** setChild #method:setChild#

#if defined(ENABLE_OVERLOADING)
    PopoverBinSetChildMethodInfo            ,
#endif
    popoverBinSetChild                      ,


-- ** setHandleInput #method:setHandleInput#

#if defined(ENABLE_OVERLOADING)
    PopoverBinSetHandleInputMethodInfo      ,
#endif
    popoverBinSetHandleInput                ,


-- ** setMenuModel #method:setMenuModel#

#if defined(ENABLE_OVERLOADING)
    PopoverBinSetMenuModelMethodInfo        ,
#endif
    popoverBinSetMenuModel                  ,


-- ** setPopover #method:setPopover#

#if defined(ENABLE_OVERLOADING)
    PopoverBinSetPopoverMethodInfo          ,
#endif
    popoverBinSetPopover                    ,




 -- * Properties


-- ** child #attr:child#
-- | The child widget of the popover bin.
-- 
-- /Since: 4.22/

#if defined(ENABLE_OVERLOADING)
    PopoverBinChildPropertyInfo             ,
#endif
    clearPopoverBinChild                    ,
    constructPopoverBinChild                ,
    getPopoverBinChild                      ,
#if defined(ENABLE_OVERLOADING)
    popoverBinChild                         ,
#endif
    setPopoverBinChild                      ,


-- ** handleInput #attr:handleInput#
-- | Whether the popover bin will handle input
-- to trigger the popup.
-- 
-- /Since: 4.22/

#if defined(ENABLE_OVERLOADING)
    PopoverBinHandleInputPropertyInfo       ,
#endif
    constructPopoverBinHandleInput          ,
    getPopoverBinHandleInput                ,
#if defined(ENABLE_OVERLOADING)
    popoverBinHandleInput                   ,
#endif
    setPopoverBinHandleInput                ,


-- ** menuModel #attr:menuModel#
-- | The @GMenuModel@ from which the popup will be created.
-- 
-- See 'GI.Gtk.Objects.PopoverBin.popoverBinSetMenuModel' for the interaction
-- with the [PopoverBin:popover]("GI.Gtk.Objects.PopoverBin#g:attr:popover") property.
-- 
-- /Since: 4.22/

#if defined(ENABLE_OVERLOADING)
    PopoverBinMenuModelPropertyInfo         ,
#endif
    clearPopoverBinMenuModel                ,
    constructPopoverBinMenuModel            ,
    getPopoverBinMenuModel                  ,
#if defined(ENABLE_OVERLOADING)
    popoverBinMenuModel                     ,
#endif
    setPopoverBinMenuModel                  ,


-- ** popover #attr:popover#
-- | The @GtkPopover@ that will be popped up when calling
-- 'GI.Gtk.Objects.PopoverBin.popoverBinPopup'.
-- 
-- /Since: 4.22/

#if defined(ENABLE_OVERLOADING)
    PopoverBinPopoverPropertyInfo           ,
#endif
    clearPopoverBinPopover                  ,
    constructPopoverBinPopover              ,
    getPopoverBinPopover                    ,
#if defined(ENABLE_OVERLOADING)
    popoverBinPopover                       ,
#endif
    setPopoverBinPopover                    ,




    ) 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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
import qualified GI.Gdk.Objects.Clipboard as Gdk.Clipboard
import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
import qualified GI.Gdk.Objects.Device as Gdk.Device
import qualified GI.Gdk.Objects.Display as Gdk.Display
import qualified GI.Gdk.Objects.Event as Gdk.Event
import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
import qualified GI.Gdk.Objects.Snapshot as Gdk.Snapshot
import qualified GI.Gdk.Objects.Surface as Gdk.Surface
import qualified GI.Gdk.Objects.Texture as Gdk.Texture
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
import qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
import qualified GI.Graphene.Structs.Point as Graphene.Point
import qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
import qualified GI.Graphene.Structs.Rect as Graphene.Rect
import qualified GI.Graphene.Structs.Size as Graphene.Size
import qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
import qualified GI.Graphene.Structs.Vec4 as Graphene.Vec4
import qualified GI.Gsk.Enums as Gsk.Enums
import qualified GI.Gsk.Flags as Gsk.Flags
import qualified GI.Gsk.Objects.GLShader as Gsk.GLShader
import qualified GI.Gsk.Objects.RenderNode as Gsk.RenderNode
import qualified GI.Gsk.Objects.Renderer as Gsk.Renderer
import qualified GI.Gsk.Structs.ColorStop as Gsk.ColorStop
import qualified GI.Gsk.Structs.ComponentTransfer as Gsk.ComponentTransfer
import qualified GI.Gsk.Structs.Path as Gsk.Path
import qualified GI.Gsk.Structs.RoundedRect as Gsk.RoundedRect
import qualified GI.Gsk.Structs.Shadow as Gsk.Shadow
import qualified GI.Gsk.Structs.Stroke as Gsk.Stroke
import qualified GI.Gsk.Structs.Transform as Gsk.Transform
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Native as Gtk.Native
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Root as Gtk.Root
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ShortcutManager as Gtk.ShortcutManager
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
import {-# SOURCE #-} qualified GI.Gtk.Objects.ATContext as Gtk.ATContext
import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController
import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutChild as Gtk.LayoutChild
import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutManager as Gtk.LayoutManager
import {-# SOURCE #-} qualified GI.Gtk.Objects.Popover as Gtk.Popover
import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
import {-# SOURCE #-} qualified GI.Gtk.Objects.Snapshot as Gtk.Snapshot
import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Gtk.Structs.Border as Gtk.Border
import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
import qualified GI.Pango.Enums as Pango.Enums
import qualified GI.Pango.Objects.Context as Pango.Context
import qualified GI.Pango.Objects.FontMap as Pango.FontMap
import qualified GI.Pango.Objects.Layout as Pango.Layout

#else
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import {-# SOURCE #-} qualified GI.Gtk.Objects.Popover as Gtk.Popover
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

#endif

-- | Memory-managed wrapper type.
newtype PopoverBin = PopoverBin (SP.ManagedPtr PopoverBin)
    deriving (Eq)

instance SP.ManagedPtrNewtype PopoverBin where
    toManagedPtr (PopoverBin p) = p

foreign import ccall "gtk_popover_bin_get_type"
    c_gtk_popover_bin_get_type :: IO B.Types.GType

instance B.Types.TypedObject PopoverBin where
    glibType = c_gtk_popover_bin_get_type

instance B.Types.GObject PopoverBin

-- | Type class for types which can be safely cast to t'PopoverBin', for instance with `toPopoverBin`.
class (SP.GObject o, O.IsDescendantOf PopoverBin o) => IsPopoverBin o
instance (SP.GObject o, O.IsDescendantOf PopoverBin o) => IsPopoverBin o

instance O.HasParentTypes PopoverBin
type instance O.ParentTypes PopoverBin = '[Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget]

-- | Cast to t'PopoverBin', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'.
toPopoverBin :: (MIO.MonadIO m, IsPopoverBin o) => o -> m PopoverBin
toPopoverBin = MIO.liftIO . B.ManagedPtr.unsafeCastTo PopoverBin

-- | Convert t'PopoverBin' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe PopoverBin) where
    gvalueGType_ = c_gtk_popover_bin_get_type
    gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr PopoverBin)
    gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv)
    gvalueGet_ gv = do
        ptr <- B.GValue.get_object gv :: IO (FP.Ptr PopoverBin)
        if ptr /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newObject PopoverBin ptr
        else return P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolvePopoverBinMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolvePopoverBinMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolvePopoverBinMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolvePopoverBinMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolvePopoverBinMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolvePopoverBinMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolvePopoverBinMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolvePopoverBinMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolvePopoverBinMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolvePopoverBinMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolvePopoverBinMethod "announce" o = Gtk.Accessible.AccessibleAnnounceMethodInfo
    ResolvePopoverBinMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolvePopoverBinMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolvePopoverBinMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolvePopoverBinMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolvePopoverBinMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolvePopoverBinMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolvePopoverBinMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolvePopoverBinMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolvePopoverBinMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolvePopoverBinMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolvePopoverBinMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolvePopoverBinMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolvePopoverBinMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolvePopoverBinMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolvePopoverBinMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolvePopoverBinMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolvePopoverBinMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolvePopoverBinMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolvePopoverBinMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolvePopoverBinMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolvePopoverBinMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolvePopoverBinMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolvePopoverBinMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolvePopoverBinMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolvePopoverBinMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolvePopoverBinMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolvePopoverBinMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolvePopoverBinMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolvePopoverBinMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolvePopoverBinMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolvePopoverBinMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolvePopoverBinMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolvePopoverBinMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolvePopoverBinMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolvePopoverBinMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolvePopoverBinMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolvePopoverBinMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolvePopoverBinMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolvePopoverBinMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolvePopoverBinMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolvePopoverBinMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolvePopoverBinMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolvePopoverBinMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolvePopoverBinMethod "popdown" o = PopoverBinPopdownMethodInfo
    ResolvePopoverBinMethod "popup" o = PopoverBinPopupMethodInfo
    ResolvePopoverBinMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolvePopoverBinMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolvePopoverBinMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolvePopoverBinMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolvePopoverBinMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolvePopoverBinMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolvePopoverBinMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolvePopoverBinMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolvePopoverBinMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolvePopoverBinMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolvePopoverBinMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolvePopoverBinMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolvePopoverBinMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolvePopoverBinMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolvePopoverBinMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolvePopoverBinMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolvePopoverBinMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolvePopoverBinMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolvePopoverBinMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolvePopoverBinMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolvePopoverBinMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolvePopoverBinMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolvePopoverBinMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolvePopoverBinMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolvePopoverBinMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolvePopoverBinMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolvePopoverBinMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolvePopoverBinMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolvePopoverBinMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
    ResolvePopoverBinMethod "updatePlatformState" o = Gtk.Accessible.AccessibleUpdatePlatformStateMethodInfo
    ResolvePopoverBinMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolvePopoverBinMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolvePopoverBinMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolvePopoverBinMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolvePopoverBinMethod "getAccessibleId" o = Gtk.Accessible.AccessibleGetAccessibleIdMethodInfo
    ResolvePopoverBinMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
    ResolvePopoverBinMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolvePopoverBinMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolvePopoverBinMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolvePopoverBinMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolvePopoverBinMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolvePopoverBinMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolvePopoverBinMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
    ResolvePopoverBinMethod "getBaseline" o = Gtk.Widget.WidgetGetBaselineMethodInfo
    ResolvePopoverBinMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
    ResolvePopoverBinMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolvePopoverBinMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolvePopoverBinMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolvePopoverBinMethod "getChild" o = PopoverBinGetChildMethodInfo
    ResolvePopoverBinMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolvePopoverBinMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolvePopoverBinMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
    ResolvePopoverBinMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolvePopoverBinMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolvePopoverBinMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolvePopoverBinMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolvePopoverBinMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolvePopoverBinMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolvePopoverBinMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
    ResolvePopoverBinMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolvePopoverBinMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolvePopoverBinMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolvePopoverBinMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolvePopoverBinMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolvePopoverBinMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolvePopoverBinMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolvePopoverBinMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolvePopoverBinMethod "getHandleInput" o = PopoverBinGetHandleInputMethodInfo
    ResolvePopoverBinMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolvePopoverBinMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolvePopoverBinMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolvePopoverBinMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolvePopoverBinMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolvePopoverBinMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolvePopoverBinMethod "getLimitEvents" o = Gtk.Widget.WidgetGetLimitEventsMethodInfo
    ResolvePopoverBinMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolvePopoverBinMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolvePopoverBinMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolvePopoverBinMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolvePopoverBinMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolvePopoverBinMethod "getMenuModel" o = PopoverBinGetMenuModelMethodInfo
    ResolvePopoverBinMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolvePopoverBinMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolvePopoverBinMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
    ResolvePopoverBinMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolvePopoverBinMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolvePopoverBinMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolvePopoverBinMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolvePopoverBinMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolvePopoverBinMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
    ResolvePopoverBinMethod "getPopover" o = PopoverBinGetPopoverMethodInfo
    ResolvePopoverBinMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolvePopoverBinMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolvePopoverBinMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolvePopoverBinMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolvePopoverBinMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolvePopoverBinMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolvePopoverBinMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolvePopoverBinMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolvePopoverBinMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolvePopoverBinMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolvePopoverBinMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolvePopoverBinMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolvePopoverBinMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolvePopoverBinMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolvePopoverBinMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolvePopoverBinMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolvePopoverBinMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolvePopoverBinMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolvePopoverBinMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolvePopoverBinMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolvePopoverBinMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolvePopoverBinMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolvePopoverBinMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolvePopoverBinMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolvePopoverBinMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
    ResolvePopoverBinMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolvePopoverBinMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolvePopoverBinMethod "setChild" o = PopoverBinSetChildMethodInfo
    ResolvePopoverBinMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolvePopoverBinMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolvePopoverBinMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolvePopoverBinMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolvePopoverBinMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolvePopoverBinMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolvePopoverBinMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolvePopoverBinMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolvePopoverBinMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolvePopoverBinMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolvePopoverBinMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolvePopoverBinMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolvePopoverBinMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolvePopoverBinMethod "setHandleInput" o = PopoverBinSetHandleInputMethodInfo
    ResolvePopoverBinMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolvePopoverBinMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolvePopoverBinMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolvePopoverBinMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolvePopoverBinMethod "setLimitEvents" o = Gtk.Widget.WidgetSetLimitEventsMethodInfo
    ResolvePopoverBinMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolvePopoverBinMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolvePopoverBinMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolvePopoverBinMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolvePopoverBinMethod "setMenuModel" o = PopoverBinSetMenuModelMethodInfo
    ResolvePopoverBinMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolvePopoverBinMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolvePopoverBinMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolvePopoverBinMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolvePopoverBinMethod "setPopover" o = PopoverBinSetPopoverMethodInfo
    ResolvePopoverBinMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolvePopoverBinMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolvePopoverBinMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolvePopoverBinMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolvePopoverBinMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolvePopoverBinMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolvePopoverBinMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolvePopoverBinMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolvePopoverBinMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolvePopoverBinMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolvePopoverBinMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolvePopoverBinMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

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

-- | Get the value of the “@child@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' popoverBin #child
-- @
getPopoverBinChild :: (MonadIO m, IsPopoverBin o) => o -> m (Maybe Gtk.Widget.Widget)
getPopoverBinChild obj = MIO.liftIO $ B.Properties.getObjectPropertyObject obj "child" Gtk.Widget.Widget

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

-- | Construct a t'GValueConstruct' with valid value for the “@child@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPopoverBinChild :: (IsPopoverBin o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructPopoverBinChild val = MIO.liftIO $ do
    MIO.liftIO $ B.Properties.constructObjectPropertyObject "child" (P.Just val)

-- | Set the value of the “@child@” 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' #child
-- @
clearPopoverBinChild :: (MonadIO m, IsPopoverBin o) => o -> m ()
clearPopoverBinChild obj = liftIO $ B.Properties.setObjectPropertyObject obj "child" (Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data PopoverBinChildPropertyInfo
instance AttrInfo PopoverBinChildPropertyInfo where
    type AttrAllowedOps PopoverBinChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PopoverBinChildPropertyInfo = IsPopoverBin
    type AttrSetTypeConstraint PopoverBinChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint PopoverBinChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType PopoverBinChildPropertyInfo = Gtk.Widget.Widget
    type AttrGetType PopoverBinChildPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel PopoverBinChildPropertyInfo = "child"
    type AttrOrigin PopoverBinChildPropertyInfo = PopoverBin
    attrGet = getPopoverBinChild
    attrSet = setPopoverBinChild
    attrPut = undefined
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructPopoverBinChild
    attrClear = clearPopoverBinChild
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.child"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#g:attr:child"
        })
#endif

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

-- | Get the value of the “@handle-input@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' popoverBin #handleInput
-- @
getPopoverBinHandleInput :: (MonadIO m, IsPopoverBin o) => o -> m Bool
getPopoverBinHandleInput obj = MIO.liftIO $ B.Properties.getObjectPropertyBool obj "handle-input"

-- | Set the value of the “@handle-input@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' popoverBin [ #handleInput 'Data.GI.Base.Attributes.:=' value ]
-- @
setPopoverBinHandleInput :: (MonadIO m, IsPopoverBin o) => o -> Bool -> m ()
setPopoverBinHandleInput obj val = MIO.liftIO $ do
    B.Properties.setObjectPropertyBool obj "handle-input" val

-- | Construct a t'GValueConstruct' with valid value for the “@handle-input@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPopoverBinHandleInput :: (IsPopoverBin o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructPopoverBinHandleInput val = MIO.liftIO $ do
    MIO.liftIO $ B.Properties.constructObjectPropertyBool "handle-input" val

#if defined(ENABLE_OVERLOADING)
data PopoverBinHandleInputPropertyInfo
instance AttrInfo PopoverBinHandleInputPropertyInfo where
    type AttrAllowedOps PopoverBinHandleInputPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
    type AttrBaseTypeConstraint PopoverBinHandleInputPropertyInfo = IsPopoverBin
    type AttrSetTypeConstraint PopoverBinHandleInputPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint PopoverBinHandleInputPropertyInfo = (~) Bool
    type AttrTransferType PopoverBinHandleInputPropertyInfo = Bool
    type AttrGetType PopoverBinHandleInputPropertyInfo = Bool
    type AttrLabel PopoverBinHandleInputPropertyInfo = "handle-input"
    type AttrOrigin PopoverBinHandleInputPropertyInfo = PopoverBin
    attrGet = getPopoverBinHandleInput
    attrSet = setPopoverBinHandleInput
    attrPut = setPopoverBinHandleInput
    attrTransfer _ v = do
        return v
    attrConstruct = constructPopoverBinHandleInput
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.handleInput"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#g:attr:handleInput"
        })
#endif

-- VVV Prop "menu-model"
   -- Type: TInterface (Name {namespace = "Gio", name = "MenuModel"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@menu-model@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' popoverBin #menuModel
-- @
getPopoverBinMenuModel :: (MonadIO m, IsPopoverBin o) => o -> m (Maybe Gio.MenuModel.MenuModel)
getPopoverBinMenuModel obj = MIO.liftIO $ B.Properties.getObjectPropertyObject obj "menu-model" Gio.MenuModel.MenuModel

-- | Set the value of the “@menu-model@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' popoverBin [ #menuModel 'Data.GI.Base.Attributes.:=' value ]
-- @
setPopoverBinMenuModel :: (MonadIO m, IsPopoverBin o, Gio.MenuModel.IsMenuModel a) => o -> a -> m ()
setPopoverBinMenuModel obj val = MIO.liftIO $ do
    B.Properties.setObjectPropertyObject obj "menu-model" (Just val)

-- | Construct a t'GValueConstruct' with valid value for the “@menu-model@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPopoverBinMenuModel :: (IsPopoverBin o, MIO.MonadIO m, Gio.MenuModel.IsMenuModel a) => a -> m (GValueConstruct o)
constructPopoverBinMenuModel val = MIO.liftIO $ do
    MIO.liftIO $ B.Properties.constructObjectPropertyObject "menu-model" (P.Just val)

-- | Set the value of the “@menu-model@” 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' #menuModel
-- @
clearPopoverBinMenuModel :: (MonadIO m, IsPopoverBin o) => o -> m ()
clearPopoverBinMenuModel obj = liftIO $ B.Properties.setObjectPropertyObject obj "menu-model" (Nothing :: Maybe Gio.MenuModel.MenuModel)

#if defined(ENABLE_OVERLOADING)
data PopoverBinMenuModelPropertyInfo
instance AttrInfo PopoverBinMenuModelPropertyInfo where
    type AttrAllowedOps PopoverBinMenuModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PopoverBinMenuModelPropertyInfo = IsPopoverBin
    type AttrSetTypeConstraint PopoverBinMenuModelPropertyInfo = Gio.MenuModel.IsMenuModel
    type AttrTransferTypeConstraint PopoverBinMenuModelPropertyInfo = Gio.MenuModel.IsMenuModel
    type AttrTransferType PopoverBinMenuModelPropertyInfo = Gio.MenuModel.MenuModel
    type AttrGetType PopoverBinMenuModelPropertyInfo = (Maybe Gio.MenuModel.MenuModel)
    type AttrLabel PopoverBinMenuModelPropertyInfo = "menu-model"
    type AttrOrigin PopoverBinMenuModelPropertyInfo = PopoverBin
    attrGet = getPopoverBinMenuModel
    attrSet = setPopoverBinMenuModel
    attrPut = undefined
    attrTransfer _ v = do
        unsafeCastTo Gio.MenuModel.MenuModel v
    attrConstruct = constructPopoverBinMenuModel
    attrClear = clearPopoverBinMenuModel
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.menuModel"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#g:attr:menuModel"
        })
#endif

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

-- | Get the value of the “@popover@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' popoverBin #popover
-- @
getPopoverBinPopover :: (MonadIO m, IsPopoverBin o) => o -> m (Maybe Gtk.Popover.Popover)
getPopoverBinPopover obj = MIO.liftIO $ B.Properties.getObjectPropertyObject obj "popover" Gtk.Popover.Popover

-- | Set the value of the “@popover@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' popoverBin [ #popover 'Data.GI.Base.Attributes.:=' value ]
-- @
setPopoverBinPopover :: (MonadIO m, IsPopoverBin o, Gtk.Popover.IsPopover a) => o -> a -> m ()
setPopoverBinPopover obj val = MIO.liftIO $ do
    B.Properties.setObjectPropertyObject obj "popover" (Just val)

-- | Construct a t'GValueConstruct' with valid value for the “@popover@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPopoverBinPopover :: (IsPopoverBin o, MIO.MonadIO m, Gtk.Popover.IsPopover a) => a -> m (GValueConstruct o)
constructPopoverBinPopover val = MIO.liftIO $ do
    MIO.liftIO $ B.Properties.constructObjectPropertyObject "popover" (P.Just val)

-- | Set the value of the “@popover@” 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' #popover
-- @
clearPopoverBinPopover :: (MonadIO m, IsPopoverBin o) => o -> m ()
clearPopoverBinPopover obj = liftIO $ B.Properties.setObjectPropertyObject obj "popover" (Nothing :: Maybe Gtk.Popover.Popover)

#if defined(ENABLE_OVERLOADING)
data PopoverBinPopoverPropertyInfo
instance AttrInfo PopoverBinPopoverPropertyInfo where
    type AttrAllowedOps PopoverBinPopoverPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PopoverBinPopoverPropertyInfo = IsPopoverBin
    type AttrSetTypeConstraint PopoverBinPopoverPropertyInfo = Gtk.Popover.IsPopover
    type AttrTransferTypeConstraint PopoverBinPopoverPropertyInfo = Gtk.Popover.IsPopover
    type AttrTransferType PopoverBinPopoverPropertyInfo = Gtk.Popover.Popover
    type AttrGetType PopoverBinPopoverPropertyInfo = (Maybe Gtk.Popover.Popover)
    type AttrLabel PopoverBinPopoverPropertyInfo = "popover"
    type AttrOrigin PopoverBinPopoverPropertyInfo = PopoverBin
    attrGet = getPopoverBinPopover
    attrSet = setPopoverBinPopover
    attrPut = undefined
    attrTransfer _ v = do
        unsafeCastTo Gtk.Popover.Popover v
    attrConstruct = constructPopoverBinPopover
    attrClear = clearPopoverBinPopover
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.popover"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#g:attr:popover"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PopoverBin
type instance O.AttributeList PopoverBin = PopoverBinAttributeList
type PopoverBinAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", PopoverBinChildPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("handleInput", PopoverBinHandleInputPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("limitEvents", Gtk.Widget.WidgetLimitEventsPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("menuModel", PopoverBinMenuModelPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("popover", PopoverBinPopoverPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
popoverBinChild :: AttrLabelProxy "child"
popoverBinChild = AttrLabelProxy

popoverBinHandleInput :: AttrLabelProxy "handleInput"
popoverBinHandleInput = AttrLabelProxy

popoverBinMenuModel :: AttrLabelProxy "menuModel"
popoverBinMenuModel = AttrLabelProxy

popoverBinPopover :: AttrLabelProxy "popover"
popoverBinPopover = AttrLabelProxy

#endif

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

#endif

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

foreign import ccall "gtk_popover_bin_new" gtk_popover_bin_new :: 
    IO (Ptr PopoverBin)

-- | Creates a new popover bin widget.
-- 
-- /Since: 4.22/
popoverBinNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m PopoverBin
    -- ^ __Returns:__ the newly created popover bin
popoverBinNew  = liftIO $ do
    result <- gtk_popover_bin_new
    checkUnexpectedReturnNULL "popoverBinNew" result
    result' <- (newObject PopoverBin) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method PopoverBin::get_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
--           , argCType = Just "GtkPopoverBin*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a popover bin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
-- throws : False
-- Skip return : False

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

-- | Retrieves the child widget of the popover bin.
-- 
-- /Since: 4.22/
popoverBinGetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
    a
    -- ^ /@self@/: a popover bin
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the child widget
popoverBinGetChild self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- gtk_popover_bin_get_child self'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gtk.Widget.Widget) result'
        return result''
    touchManagedPtr self
    return maybeResult

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

instance O.OverloadedMethodInfo PopoverBinGetChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.popoverBinGetChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#v:popoverBinGetChild"
        })


#endif

-- method PopoverBin::get_handle_input
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
--           , argCType = Just "GtkPopoverBin*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_popover_bin_get_handle_input" gtk_popover_bin_get_handle_input :: 
    Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
    IO CInt

-- | /No description available in the introspection data./
popoverBinGetHandleInput ::
    (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
    a
    -> m Bool
popoverBinGetHandleInput self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- gtk_popover_bin_get_handle_input self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data PopoverBinGetHandleInputMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPopoverBin a) => O.OverloadedMethod PopoverBinGetHandleInputMethodInfo a signature where
    overloadedMethod = popoverBinGetHandleInput

instance O.OverloadedMethodInfo PopoverBinGetHandleInputMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.popoverBinGetHandleInput",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#v:popoverBinGetHandleInput"
        })


#endif

-- method PopoverBin::get_menu_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
--           , argCType = Just "GtkPopoverBin*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a popover bin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "MenuModel" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_popover_bin_get_menu_model" gtk_popover_bin_get_menu_model :: 
    Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
    IO (Ptr Gio.MenuModel.MenuModel)

-- | Retrieves the menu model set using 'GI.Gtk.Objects.PopoverBin.popoverBinSetMenuModel'.
-- 
-- /Since: 4.22/
popoverBinGetMenuModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
    a
    -- ^ /@self@/: a popover bin
    -> m (Maybe Gio.MenuModel.MenuModel)
    -- ^ __Returns:__ the menu model for the popover
popoverBinGetMenuModel self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- gtk_popover_bin_get_menu_model self'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gio.MenuModel.MenuModel) result'
        return result''
    touchManagedPtr self
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data PopoverBinGetMenuModelMethodInfo
instance (signature ~ (m (Maybe Gio.MenuModel.MenuModel)), MonadIO m, IsPopoverBin a) => O.OverloadedMethod PopoverBinGetMenuModelMethodInfo a signature where
    overloadedMethod = popoverBinGetMenuModel

instance O.OverloadedMethodInfo PopoverBinGetMenuModelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.popoverBinGetMenuModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#v:popoverBinGetMenuModel"
        })


#endif

-- method PopoverBin::get_popover
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
--           , argCType = Just "GtkPopoverBin*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a popover bin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Popover" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_popover_bin_get_popover" gtk_popover_bin_get_popover :: 
    Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
    IO (Ptr Gtk.Popover.Popover)

-- | Retrieves the @GtkPopover@ set using 'GI.Gtk.Objects.PopoverBin.popoverBinSetPopover'.
-- 
-- /Since: 4.22/
popoverBinGetPopover ::
    (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
    a
    -- ^ /@self@/: a popover bin
    -> m (Maybe Gtk.Popover.Popover)
    -- ^ __Returns:__ a popover widget
popoverBinGetPopover self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- gtk_popover_bin_get_popover self'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gtk.Popover.Popover) result'
        return result''
    touchManagedPtr self
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data PopoverBinGetPopoverMethodInfo
instance (signature ~ (m (Maybe Gtk.Popover.Popover)), MonadIO m, IsPopoverBin a) => O.OverloadedMethod PopoverBinGetPopoverMethodInfo a signature where
    overloadedMethod = popoverBinGetPopover

instance O.OverloadedMethodInfo PopoverBinGetPopoverMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.popoverBinGetPopover",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#v:popoverBinGetPopover"
        })


#endif

-- method PopoverBin::popdown
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
--           , argCType = Just "GtkPopoverBin*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a popover bin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_popover_bin_popdown" gtk_popover_bin_popdown :: 
    Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
    IO ()

-- | Hides the popover from the user.
-- 
-- See: 'GI.Gtk.Objects.PopoverBin.popoverBinPopup'
-- 
-- /Since: 4.22/
popoverBinPopdown ::
    (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
    a
    -- ^ /@self@/: a popover bin
    -> m ()
popoverBinPopdown self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    gtk_popover_bin_popdown self'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PopoverBinPopdownMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPopoverBin a) => O.OverloadedMethod PopoverBinPopdownMethodInfo a signature where
    overloadedMethod = popoverBinPopdown

instance O.OverloadedMethodInfo PopoverBinPopdownMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.popoverBinPopdown",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#v:popoverBinPopdown"
        })


#endif

-- method PopoverBin::popup
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
--           , argCType = Just "GtkPopoverBin*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a popover bin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_popover_bin_popup" gtk_popover_bin_popup :: 
    Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
    IO ()

-- | Presents the popover to the user.
-- 
-- Use 'GI.Gtk.Objects.PopoverBin.popoverBinSetPopover' or
-- 'GI.Gtk.Objects.PopoverBin.popoverBinSetMenuModel' to define the popover.
-- 
-- See: 'GI.Gtk.Objects.PopoverBin.popoverBinPopdown'
-- 
-- /Since: 4.22/
popoverBinPopup ::
    (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
    a
    -- ^ /@self@/: a popover bin
    -> m ()
popoverBinPopup self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    gtk_popover_bin_popup self'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PopoverBinPopupMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPopoverBin a) => O.OverloadedMethod PopoverBinPopupMethodInfo a signature where
    overloadedMethod = popoverBinPopup

instance O.OverloadedMethodInfo PopoverBinPopupMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.popoverBinPopup",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#v:popoverBinPopup"
        })


#endif

-- method PopoverBin::set_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
--           , argCType = Just "GtkPopoverBin*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a popover bin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the child of the popover bin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the child of the popover bin.
-- 
-- /Since: 4.22/
popoverBinSetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a popover bin
    -> Maybe (b)
    -- ^ /@child@/: the child of the popover bin
    -> m ()
popoverBinSetChild self child = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeChild <- case child of
        Nothing -> return FP.nullPtr
        Just jChild -> do
            jChild' <- unsafeManagedPtrCastPtr jChild
            return jChild'
    gtk_popover_bin_set_child self' maybeChild
    touchManagedPtr self
    whenJust child touchManagedPtr
    return ()

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

instance O.OverloadedMethodInfo PopoverBinSetChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.popoverBinSetChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#v:popoverBinSetChild"
        })


#endif

-- method PopoverBin::set_handle_input
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
--           , argCType = Just "GtkPopoverBin*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a popover bin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "handle_input"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to handle input"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_popover_bin_set_handle_input" gtk_popover_bin_set_handle_input :: 
    Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
    CInt ->                                 -- handle_input : TBasicType TBoolean
    IO ()

-- | Enables or disables input handling.
-- 
-- If enabled, the popover bin will pop up the
-- popover on right-click or long press, as expected
-- for a context menu.
-- 
-- /Since: 4.22/
popoverBinSetHandleInput ::
    (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a) =>
    a
    -- ^ /@self@/: a popover bin
    -> Bool
    -- ^ /@handleInput@/: whether to handle input
    -> m ()
popoverBinSetHandleInput self handleInput = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let handleInput' = (P.fromIntegral . P.fromEnum) handleInput
    gtk_popover_bin_set_handle_input self' handleInput'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data PopoverBinSetHandleInputMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsPopoverBin a) => O.OverloadedMethod PopoverBinSetHandleInputMethodInfo a signature where
    overloadedMethod = popoverBinSetHandleInput

instance O.OverloadedMethodInfo PopoverBinSetHandleInputMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.popoverBinSetHandleInput",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#v:popoverBinSetHandleInput"
        })


#endif

-- method PopoverBin::set_menu_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
--           , argCType = Just "GtkPopoverBin*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a popover bin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "model"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuModel" }
--           , argCType = Just "GMenuModel*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a menu model" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_popover_bin_set_menu_model" gtk_popover_bin_set_menu_model :: 
    Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
    Ptr Gio.MenuModel.MenuModel ->          -- model : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    IO ()

-- | Sets the menu model used to create the popover that will be
-- presented when calling 'GI.Gtk.Objects.PopoverBin.popoverBinPopup'.
-- 
-- If /@model@/ is @NULL@, the popover will be unset.
-- 
-- A t'GI.Gtk.Objects.Popover.Popover' will be created from the menu model with
-- 'GI.Gtk.Objects.PopoverMenu.popoverMenuNewFromModel'. Actions will be connected
-- as documented for this function.
-- 
-- If [PopoverBin:popover]("GI.Gtk.Objects.PopoverBin#g:attr:popover") is already set, it will be
-- dissociated from the popover bin, and the property is set to @NULL@.
-- 
-- See: 'GI.Gtk.Objects.PopoverBin.popoverBinSetPopover'
-- 
-- /Since: 4.22/
popoverBinSetMenuModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a, Gio.MenuModel.IsMenuModel b) =>
    a
    -- ^ /@self@/: a popover bin
    -> Maybe (b)
    -- ^ /@model@/: a menu model
    -> m ()
popoverBinSetMenuModel self model = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeModel <- case model of
        Nothing -> return FP.nullPtr
        Just jModel -> do
            jModel' <- unsafeManagedPtrCastPtr jModel
            return jModel'
    gtk_popover_bin_set_menu_model self' maybeModel
    touchManagedPtr self
    whenJust model touchManagedPtr
    return ()

#if defined(ENABLE_OVERLOADING)
data PopoverBinSetMenuModelMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsPopoverBin a, Gio.MenuModel.IsMenuModel b) => O.OverloadedMethod PopoverBinSetMenuModelMethodInfo a signature where
    overloadedMethod = popoverBinSetMenuModel

instance O.OverloadedMethodInfo PopoverBinSetMenuModelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.popoverBinSetMenuModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#v:popoverBinSetMenuModel"
        })


#endif

-- method PopoverBin::set_popover
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PopoverBin" }
--           , argCType = Just "GtkPopoverBin*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a popover bin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "popover"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Popover" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkPopover`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_popover_bin_set_popover" gtk_popover_bin_set_popover :: 
    Ptr PopoverBin ->                       -- self : TInterface (Name {namespace = "Gtk", name = "PopoverBin"})
    Ptr Gtk.Popover.Popover ->              -- popover : TInterface (Name {namespace = "Gtk", name = "Popover"})
    IO ()

-- | Sets the @GtkPopover@ that will be presented when calling
-- 'GI.Gtk.Objects.PopoverBin.popoverBinPopup'.
-- 
-- If /@popover@/ is @NULL@, the popover will be unset.
-- 
-- If [PopoverBin:menuModel]("GI.Gtk.Objects.PopoverBin#g:attr:menuModel") is set before calling
-- this function, then the menu model property will be unset.
-- 
-- See: 'GI.Gtk.Objects.PopoverBin.popoverBinSetMenuModel'
-- 
-- /Since: 4.22/
popoverBinSetPopover ::
    (B.CallStack.HasCallStack, MonadIO m, IsPopoverBin a, Gtk.Popover.IsPopover b) =>
    a
    -- ^ /@self@/: a popover bin
    -> Maybe (b)
    -- ^ /@popover@/: a @GtkPopover@
    -> m ()
popoverBinSetPopover self popover = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybePopover <- case popover of
        Nothing -> return FP.nullPtr
        Just jPopover -> do
            jPopover' <- unsafeManagedPtrCastPtr jPopover
            return jPopover'
    gtk_popover_bin_set_popover self' maybePopover
    touchManagedPtr self
    whenJust popover touchManagedPtr
    return ()

#if defined(ENABLE_OVERLOADING)
data PopoverBinSetPopoverMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsPopoverBin a, Gtk.Popover.IsPopover b) => O.OverloadedMethod PopoverBinSetPopoverMethodInfo a signature where
    overloadedMethod = popoverBinSetPopover

instance O.OverloadedMethodInfo PopoverBinSetPopoverMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.PopoverBin.popoverBinSetPopover",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.11/docs/GI-Gtk-Objects-PopoverBin.html#v:popoverBinSetPopover"
        })


#endif


