{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @GtkListBoxRow@ is the kind of widget that can be added to a @GtkListBox@.

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

module GI.Gtk.Objects.ListBoxRow
    ( 

-- * Exported types
    ListBoxRow(..)                          ,
    IsListBoxRow                            ,
    toListBoxRow                            ,


 -- * 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"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [changed]("GI.Gtk.Objects.ListBoxRow#g:method:changed"), [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"), [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"), [isSelected]("GI.Gtk.Objects.ListBoxRow#g:method:isSelected"), [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"), [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"), [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
-- [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getActionName]("GI.Gtk.Interfaces.Actionable#g:method:getActionName"), [getActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:getActionTargetValue"), [getActivatable]("GI.Gtk.Objects.ListBoxRow#g:method:getActivatable"), [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"), [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.ListBoxRow#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [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"), [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"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeader]("GI.Gtk.Objects.ListBoxRow#g:method:getHeader"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getIndex]("GI.Gtk.Objects.ListBoxRow#g:method:getIndex"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [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"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [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"), [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"), [getSelectable]("GI.Gtk.Objects.ListBoxRow#g:method:getSelectable"), [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
-- [setActionName]("GI.Gtk.Interfaces.Actionable#g:method:setActionName"), [setActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:setActionTargetValue"), [setActivatable]("GI.Gtk.Objects.ListBoxRow#g:method:setActivatable"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChild]("GI.Gtk.Objects.ListBoxRow#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"), [setDetailedActionName]("GI.Gtk.Interfaces.Actionable#g:method:setDetailedActionName"), [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"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHeader]("GI.Gtk.Objects.ListBoxRow#g:method:setHeader"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [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"), [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"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSelectable]("GI.Gtk.Objects.ListBoxRow#g:method:setSelectable"), [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)
    ResolveListBoxRowMethod                 ,
#endif

-- ** changed #method:changed#

#if defined(ENABLE_OVERLOADING)
    ListBoxRowChangedMethodInfo             ,
#endif
    listBoxRowChanged                       ,


-- ** getActivatable #method:getActivatable#

#if defined(ENABLE_OVERLOADING)
    ListBoxRowGetActivatableMethodInfo      ,
#endif
    listBoxRowGetActivatable                ,


-- ** getChild #method:getChild#

#if defined(ENABLE_OVERLOADING)
    ListBoxRowGetChildMethodInfo            ,
#endif
    listBoxRowGetChild                      ,


-- ** getHeader #method:getHeader#

#if defined(ENABLE_OVERLOADING)
    ListBoxRowGetHeaderMethodInfo           ,
#endif
    listBoxRowGetHeader                     ,


-- ** getIndex #method:getIndex#

#if defined(ENABLE_OVERLOADING)
    ListBoxRowGetIndexMethodInfo            ,
#endif
    listBoxRowGetIndex                      ,


-- ** getSelectable #method:getSelectable#

#if defined(ENABLE_OVERLOADING)
    ListBoxRowGetSelectableMethodInfo       ,
#endif
    listBoxRowGetSelectable                 ,


-- ** isSelected #method:isSelected#

#if defined(ENABLE_OVERLOADING)
    ListBoxRowIsSelectedMethodInfo          ,
#endif
    listBoxRowIsSelected                    ,


-- ** new #method:new#

    listBoxRowNew                           ,


-- ** setActivatable #method:setActivatable#

#if defined(ENABLE_OVERLOADING)
    ListBoxRowSetActivatableMethodInfo      ,
#endif
    listBoxRowSetActivatable                ,


-- ** setChild #method:setChild#

#if defined(ENABLE_OVERLOADING)
    ListBoxRowSetChildMethodInfo            ,
#endif
    listBoxRowSetChild                      ,


-- ** setHeader #method:setHeader#

#if defined(ENABLE_OVERLOADING)
    ListBoxRowSetHeaderMethodInfo           ,
#endif
    listBoxRowSetHeader                     ,


-- ** setSelectable #method:setSelectable#

#if defined(ENABLE_OVERLOADING)
    ListBoxRowSetSelectableMethodInfo       ,
#endif
    listBoxRowSetSelectable                 ,




 -- * Properties


-- ** activatable #attr:activatable#
-- | Determines whether the [rowActivated](#g:signal:rowActivated)
-- signal will be emitted for this row.

#if defined(ENABLE_OVERLOADING)
    ListBoxRowActivatablePropertyInfo       ,
#endif
    constructListBoxRowActivatable          ,
    getListBoxRowActivatable                ,
#if defined(ENABLE_OVERLOADING)
    listBoxRowActivatable                   ,
#endif
    setListBoxRowActivatable                ,


-- ** child #attr:child#
-- | The child widget.

#if defined(ENABLE_OVERLOADING)
    ListBoxRowChildPropertyInfo             ,
#endif
    clearListBoxRowChild                    ,
    constructListBoxRowChild                ,
    getListBoxRowChild                      ,
#if defined(ENABLE_OVERLOADING)
    listBoxRowChild                         ,
#endif
    setListBoxRowChild                      ,


-- ** selectable #attr:selectable#
-- | Determines whether this row can be selected.

#if defined(ENABLE_OVERLOADING)
    ListBoxRowSelectablePropertyInfo        ,
#endif
    constructListBoxRowSelectable           ,
    getListBoxRowSelectable                 ,
#if defined(ENABLE_OVERLOADING)
    listBoxRowSelectable                    ,
#endif
    setListBoxRowSelectable                 ,




 -- * Signals


-- ** activate #signal:activate#

    ListBoxRowActivateCallback              ,
#if defined(ENABLE_OVERLOADING)
    ListBoxRowActivateSignalInfo            ,
#endif
    afterListBoxRowActivate                 ,
    onListBoxRowActivate                    ,




    ) where

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

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

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable
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.Widget as Gtk.Widget

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

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

foreign import ccall "gtk_list_box_row_get_type"
    c_gtk_list_box_row_get_type :: IO B.Types.GType

instance B.Types.TypedObject ListBoxRow where
    glibType :: IO GType
glibType = IO GType
c_gtk_list_box_row_get_type

instance B.Types.GObject ListBoxRow

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

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

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

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

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

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

#endif

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

#endif

-- signal ListBoxRow::activate
-- | This is a keybinding signal, which will cause this row to be activated.
-- 
-- If you want to be notified when the user activates a row (by key or not),
-- use the [ListBox::rowActivated]("GI.Gtk.Objects.ListBox#g:signal:rowActivated") signal on the row’s parent
-- @GtkListBox@.
type ListBoxRowActivateCallback =
    IO ()

type C_ListBoxRowActivateCallback =
    Ptr ListBoxRow ->                       -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_ListBoxRowActivateCallback :: 
    GObject a => (a -> ListBoxRowActivateCallback) ->
    C_ListBoxRowActivateCallback
wrap_ListBoxRowActivateCallback :: forall a. GObject a => (a -> IO ()) -> C_ListBoxRowActivateCallback
wrap_ListBoxRowActivateCallback a -> IO ()
gi'cb Ptr ListBoxRow
gi'selfPtr Ptr ()
_ = do
    Ptr ListBoxRow -> (ListBoxRow -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ListBoxRow
gi'selfPtr ((ListBoxRow -> IO ()) -> IO ()) -> (ListBoxRow -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ListBoxRow
gi'self -> a -> IO ()
gi'cb (ListBoxRow -> a
Coerce.coerce ListBoxRow
gi'self) 


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

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


#if defined(ENABLE_OVERLOADING)
data ListBoxRowActivateSignalInfo
instance SignalInfo ListBoxRowActivateSignalInfo where
    type HaskellCallbackType ListBoxRowActivateSignalInfo = ListBoxRowActivateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ListBoxRowActivateCallback cb
        cb'' <- mk_ListBoxRowActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ListBoxRow::activate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.5/docs/GI-Gtk-Objects-ListBoxRow.html#g:signal:activate"})

#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data ListBoxRowActivatablePropertyInfo
instance AttrInfo ListBoxRowActivatablePropertyInfo where
    type AttrAllowedOps ListBoxRowActivatablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ListBoxRowActivatablePropertyInfo = IsListBoxRow
    type AttrSetTypeConstraint ListBoxRowActivatablePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ListBoxRowActivatablePropertyInfo = (~) Bool
    type AttrTransferType ListBoxRowActivatablePropertyInfo = Bool
    type AttrGetType ListBoxRowActivatablePropertyInfo = Bool
    type AttrLabel ListBoxRowActivatablePropertyInfo = "activatable"
    type AttrOrigin ListBoxRowActivatablePropertyInfo = ListBoxRow
    attrGet = getListBoxRowActivatable
    attrSet = setListBoxRowActivatable
    attrTransfer _ v = do
        return v
    attrConstruct = constructListBoxRowActivatable
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ListBoxRow.activatable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.5/docs/GI-Gtk-Objects-ListBoxRow.html#g:attr:activatable"
        })
#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' listBoxRow #child
-- @
getListBoxRowChild :: (MonadIO m, IsListBoxRow o) => o -> m (Maybe Gtk.Widget.Widget)
getListBoxRowChild :: forall (m :: * -> *) o.
(MonadIO m, IsListBoxRow o) =>
o -> m (Maybe Widget)
getListBoxRowChild o
obj = IO (Maybe Widget) -> m (Maybe Widget)
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
"child" ManagedPtr Widget -> Widget
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' listBoxRow [ #child 'Data.GI.Base.Attributes.:=' value ]
-- @
setListBoxRowChild :: (MonadIO m, IsListBoxRow o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setListBoxRowChild :: forall (m :: * -> *) o a.
(MonadIO m, IsListBoxRow o, IsWidget a) =>
o -> a -> m ()
setListBoxRowChild o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"child" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

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

#if defined(ENABLE_OVERLOADING)
data ListBoxRowChildPropertyInfo
instance AttrInfo ListBoxRowChildPropertyInfo where
    type AttrAllowedOps ListBoxRowChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ListBoxRowChildPropertyInfo = IsListBoxRow
    type AttrSetTypeConstraint ListBoxRowChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint ListBoxRowChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType ListBoxRowChildPropertyInfo = Gtk.Widget.Widget
    type AttrGetType ListBoxRowChildPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel ListBoxRowChildPropertyInfo = "child"
    type AttrOrigin ListBoxRowChildPropertyInfo = ListBoxRow
    attrGet = getListBoxRowChild
    attrSet = setListBoxRowChild
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructListBoxRowChild
    attrClear = clearListBoxRowChild
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ListBoxRow.child"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.5/docs/GI-Gtk-Objects-ListBoxRow.html#g:attr:child"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data ListBoxRowSelectablePropertyInfo
instance AttrInfo ListBoxRowSelectablePropertyInfo where
    type AttrAllowedOps ListBoxRowSelectablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ListBoxRowSelectablePropertyInfo = IsListBoxRow
    type AttrSetTypeConstraint ListBoxRowSelectablePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ListBoxRowSelectablePropertyInfo = (~) Bool
    type AttrTransferType ListBoxRowSelectablePropertyInfo = Bool
    type AttrGetType ListBoxRowSelectablePropertyInfo = Bool
    type AttrLabel ListBoxRowSelectablePropertyInfo = "selectable"
    type AttrOrigin ListBoxRowSelectablePropertyInfo = ListBoxRow
    attrGet = getListBoxRowSelectable
    attrSet = setListBoxRowSelectable
    attrTransfer _ v = do
        return v
    attrConstruct = constructListBoxRowSelectable
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ListBoxRow.selectable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.5/docs/GI-Gtk-Objects-ListBoxRow.html#g:attr:selectable"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ListBoxRow
type instance O.AttributeList ListBoxRow = ListBoxRowAttributeList
type ListBoxRowAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("activatable", ListBoxRowActivatablePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", ListBoxRowChildPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("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), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("selectable", ListBoxRowSelectablePropertyInfo), '("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, *)])
#endif

#if defined(ENABLE_OVERLOADING)
listBoxRowActivatable :: AttrLabelProxy "activatable"
listBoxRowActivatable = AttrLabelProxy

listBoxRowChild :: AttrLabelProxy "child"
listBoxRowChild = AttrLabelProxy

listBoxRowSelectable :: AttrLabelProxy "selectable"
listBoxRowSelectable = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ListBoxRow = ListBoxRowSignalList
type ListBoxRowSignalList = ('[ '("activate", ListBoxRowActivateSignalInfo), '("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, *)])

#endif

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

foreign import ccall "gtk_list_box_row_new" gtk_list_box_row_new :: 
    IO (Ptr ListBoxRow)

-- | Creates a new @GtkListBoxRow@.
listBoxRowNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ListBoxRow
    -- ^ __Returns:__ a new @GtkListBoxRow@
listBoxRowNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ListBoxRow
listBoxRowNew  = IO ListBoxRow -> m ListBoxRow
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ListBoxRow -> m ListBoxRow) -> IO ListBoxRow -> m ListBoxRow
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListBoxRow
result <- IO (Ptr ListBoxRow)
gtk_list_box_row_new
    Text -> Ptr ListBoxRow -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"listBoxRowNew" Ptr ListBoxRow
result
    ListBoxRow
result' <- ((ManagedPtr ListBoxRow -> ListBoxRow)
-> Ptr ListBoxRow -> IO ListBoxRow
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListBoxRow -> ListBoxRow
ListBoxRow) Ptr ListBoxRow
result
    ListBoxRow -> IO ListBoxRow
forall (m :: * -> *) a. Monad m => a -> m a
return ListBoxRow
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method ListBoxRow::changed
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "row"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListBoxRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkListBoxRow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_list_box_row_changed" gtk_list_box_row_changed :: 
    Ptr ListBoxRow ->                       -- row : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})
    IO ()

-- | Marks /@row@/ as changed, causing any state that depends on this
-- to be updated.
-- 
-- This affects sorting, filtering and headers.
-- 
-- Note that calls to this method must be in sync with the data
-- used for the row functions. For instance, if the list is
-- mirroring some external data set, and *two* rows changed in the
-- external data set then when you call 'GI.Gtk.Objects.ListBoxRow.listBoxRowChanged'
-- on the first row the sort function must only read the new data
-- for the first of the two changed rows, otherwise the resorting
-- of the rows will be wrong.
-- 
-- This generally means that if you don’t fully control the data
-- model you have to duplicate the data that affects the listbox
-- row functions into the row widgets themselves. Another alternative
-- is to call 'GI.Gtk.Objects.ListBox.listBoxInvalidateSort' on any model change,
-- but that is more expensive.
listBoxRowChanged ::
    (B.CallStack.HasCallStack, MonadIO m, IsListBoxRow a) =>
    a
    -- ^ /@row@/: a @GtkListBoxRow@
    -> m ()
listBoxRowChanged :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListBoxRow a) =>
a -> m ()
listBoxRowChanged a
row = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListBoxRow
row' <- a -> IO (Ptr ListBoxRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
row
    Ptr ListBoxRow -> IO ()
gtk_list_box_row_changed Ptr ListBoxRow
row'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
row
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ListBoxRowChangedMethodInfo
instance (signature ~ (m ()), MonadIO m, IsListBoxRow a) => O.OverloadedMethod ListBoxRowChangedMethodInfo a signature where
    overloadedMethod = listBoxRowChanged

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


#endif

-- method ListBoxRow::get_activatable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "row"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListBoxRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkListBoxRow`" , 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 "gtk_list_box_row_get_activatable" gtk_list_box_row_get_activatable :: 
    Ptr ListBoxRow ->                       -- row : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})
    IO CInt

-- | Gets whether the row is activatable.
listBoxRowGetActivatable ::
    (B.CallStack.HasCallStack, MonadIO m, IsListBoxRow a) =>
    a
    -- ^ /@row@/: a @GtkListBoxRow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the row is activatable
listBoxRowGetActivatable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListBoxRow a) =>
a -> m Bool
listBoxRowGetActivatable a
row = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListBoxRow
row' <- a -> IO (Ptr ListBoxRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
row
    CInt
result <- Ptr ListBoxRow -> IO CInt
gtk_list_box_row_get_activatable Ptr ListBoxRow
row'
    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
row
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ListBoxRowGetActivatableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsListBoxRow a) => O.OverloadedMethod ListBoxRowGetActivatableMethodInfo a signature where
    overloadedMethod = listBoxRowGetActivatable

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


#endif

-- method ListBoxRow::get_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "row"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListBoxRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkListBoxRow`" , 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 "gtk_list_box_row_get_child" gtk_list_box_row_get_child :: 
    Ptr ListBoxRow ->                       -- row : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})
    IO (Ptr Gtk.Widget.Widget)

-- | Gets the child widget of /@row@/.
listBoxRowGetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsListBoxRow a) =>
    a
    -- ^ /@row@/: a @GtkListBoxRow@
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the child widget of /@row@/
listBoxRowGetChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListBoxRow a) =>
a -> m (Maybe Widget)
listBoxRowGetChild a
row = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListBoxRow
row' <- a -> IO (Ptr ListBoxRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
row
    Ptr Widget
result <- Ptr ListBoxRow -> IO (Ptr Widget)
gtk_list_box_row_get_child Ptr ListBoxRow
row'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
row
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

-- method ListBoxRow::get_header
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "row"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListBoxRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkListBoxRow`" , 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 "gtk_list_box_row_get_header" gtk_list_box_row_get_header :: 
    Ptr ListBoxRow ->                       -- row : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})
    IO (Ptr Gtk.Widget.Widget)

-- | Returns the current header of the /@row@/.
-- 
-- This can be used
-- in a [callback/@gtk@/.ListBoxUpdateHeaderFunc] to see if
-- there is a header set already, and if so to update
-- the state of it.
listBoxRowGetHeader ::
    (B.CallStack.HasCallStack, MonadIO m, IsListBoxRow a) =>
    a
    -- ^ /@row@/: a @GtkListBoxRow@
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the current header
listBoxRowGetHeader :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListBoxRow a) =>
a -> m (Maybe Widget)
listBoxRowGetHeader a
row = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListBoxRow
row' <- a -> IO (Ptr ListBoxRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
row
    Ptr Widget
result <- Ptr ListBoxRow -> IO (Ptr Widget)
gtk_list_box_row_get_header Ptr ListBoxRow
row'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
row
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

-- method ListBoxRow::get_index
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "row"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListBoxRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkListBoxRow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_list_box_row_get_index" gtk_list_box_row_get_index :: 
    Ptr ListBoxRow ->                       -- row : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})
    IO Int32

-- | Gets the current index of the /@row@/ in its @GtkListBox@ container.
listBoxRowGetIndex ::
    (B.CallStack.HasCallStack, MonadIO m, IsListBoxRow a) =>
    a
    -- ^ /@row@/: a @GtkListBoxRow@
    -> m Int32
    -- ^ __Returns:__ the index of the /@row@/, or -1 if the /@row@/ is not in a listbox
listBoxRowGetIndex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListBoxRow a) =>
a -> m Int32
listBoxRowGetIndex a
row = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListBoxRow
row' <- a -> IO (Ptr ListBoxRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
row
    Int32
result <- Ptr ListBoxRow -> IO Int32
gtk_list_box_row_get_index Ptr ListBoxRow
row'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
row
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ListBoxRowGetIndexMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsListBoxRow a) => O.OverloadedMethod ListBoxRowGetIndexMethodInfo a signature where
    overloadedMethod = listBoxRowGetIndex

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


#endif

-- method ListBoxRow::get_selectable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "row"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListBoxRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkListBoxRow`" , 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 "gtk_list_box_row_get_selectable" gtk_list_box_row_get_selectable :: 
    Ptr ListBoxRow ->                       -- row : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})
    IO CInt

-- | Gets whether the row can be selected.
listBoxRowGetSelectable ::
    (B.CallStack.HasCallStack, MonadIO m, IsListBoxRow a) =>
    a
    -- ^ /@row@/: a @GtkListBoxRow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the row is selectable
listBoxRowGetSelectable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListBoxRow a) =>
a -> m Bool
listBoxRowGetSelectable a
row = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListBoxRow
row' <- a -> IO (Ptr ListBoxRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
row
    CInt
result <- Ptr ListBoxRow -> IO CInt
gtk_list_box_row_get_selectable Ptr ListBoxRow
row'
    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
row
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ListBoxRowGetSelectableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsListBoxRow a) => O.OverloadedMethod ListBoxRowGetSelectableMethodInfo a signature where
    overloadedMethod = listBoxRowGetSelectable

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


#endif

-- method ListBoxRow::is_selected
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "row"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListBoxRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkListBoxRow`" , 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 "gtk_list_box_row_is_selected" gtk_list_box_row_is_selected :: 
    Ptr ListBoxRow ->                       -- row : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})
    IO CInt

-- | Returns whether the child is currently selected in its
-- @GtkListBox@ container.
listBoxRowIsSelected ::
    (B.CallStack.HasCallStack, MonadIO m, IsListBoxRow a) =>
    a
    -- ^ /@row@/: a @GtkListBoxRow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@row@/ is selected
listBoxRowIsSelected :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListBoxRow a) =>
a -> m Bool
listBoxRowIsSelected a
row = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListBoxRow
row' <- a -> IO (Ptr ListBoxRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
row
    CInt
result <- Ptr ListBoxRow -> IO CInt
gtk_list_box_row_is_selected Ptr ListBoxRow
row'
    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
row
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ListBoxRowIsSelectedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsListBoxRow a) => O.OverloadedMethod ListBoxRowIsSelectedMethodInfo a signature where
    overloadedMethod = listBoxRowIsSelected

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


#endif

-- method ListBoxRow::set_activatable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "row"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListBoxRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkListBoxRow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "activatable"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to mark the row as activatable"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_list_box_row_set_activatable" gtk_list_box_row_set_activatable :: 
    Ptr ListBoxRow ->                       -- row : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})
    CInt ->                                 -- activatable : TBasicType TBoolean
    IO ()

-- | Set whether the row is activatable.
listBoxRowSetActivatable ::
    (B.CallStack.HasCallStack, MonadIO m, IsListBoxRow a) =>
    a
    -- ^ /@row@/: a @GtkListBoxRow@
    -> Bool
    -- ^ /@activatable@/: 'P.True' to mark the row as activatable
    -> m ()
listBoxRowSetActivatable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListBoxRow a) =>
a -> Bool -> m ()
listBoxRowSetActivatable a
row Bool
activatable = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListBoxRow
row' <- a -> IO (Ptr ListBoxRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
row
    let activatable' :: CInt
activatable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
activatable
    Ptr ListBoxRow -> CInt -> IO ()
gtk_list_box_row_set_activatable Ptr ListBoxRow
row' CInt
activatable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
row
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ListBoxRowSetActivatableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsListBoxRow a) => O.OverloadedMethod ListBoxRowSetActivatableMethodInfo a signature where
    overloadedMethod = listBoxRowSetActivatable

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


#endif

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

foreign import ccall "gtk_list_box_row_set_child" gtk_list_box_row_set_child :: 
    Ptr ListBoxRow ->                       -- row : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the child widget of /@self@/.
listBoxRowSetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsListBoxRow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@row@/: a @GtkListBoxRow@
    -> Maybe (b)
    -- ^ /@child@/: the child widget
    -> m ()
listBoxRowSetChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsListBoxRow a, IsWidget b) =>
a -> Maybe b -> m ()
listBoxRowSetChild a
row Maybe b
child = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListBoxRow
row' <- a -> IO (Ptr ListBoxRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
row
    Ptr Widget
maybeChild <- case Maybe b
child of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jChild -> do
            Ptr Widget
jChild' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jChild
            Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jChild'
    Ptr ListBoxRow -> Ptr Widget -> IO ()
gtk_list_box_row_set_child Ptr ListBoxRow
row' Ptr Widget
maybeChild
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
row
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
child b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

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

foreign import ccall "gtk_list_box_row_set_header" gtk_list_box_row_set_header :: 
    Ptr ListBoxRow ->                       -- row : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})
    Ptr Gtk.Widget.Widget ->                -- header : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the current header of the /@row@/.
-- 
-- This is only allowed to be called
-- from a [callback/@gtk@/.ListBoxUpdateHeaderFunc].
-- It will replace any existing header in the row,
-- and be shown in front of the row in the listbox.
listBoxRowSetHeader ::
    (B.CallStack.HasCallStack, MonadIO m, IsListBoxRow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@row@/: a @GtkListBoxRow@
    -> Maybe (b)
    -- ^ /@header@/: the header
    -> m ()
listBoxRowSetHeader :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsListBoxRow a, IsWidget b) =>
a -> Maybe b -> m ()
listBoxRowSetHeader a
row Maybe b
header = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListBoxRow
row' <- a -> IO (Ptr ListBoxRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
row
    Ptr Widget
maybeHeader <- case Maybe b
header of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jHeader -> do
            Ptr Widget
jHeader' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jHeader
            Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jHeader'
    Ptr ListBoxRow -> Ptr Widget -> IO ()
gtk_list_box_row_set_header Ptr ListBoxRow
row' Ptr Widget
maybeHeader
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
row
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
header b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method ListBoxRow::set_selectable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "row"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListBoxRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkListBoxRow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "selectable"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to mark the row as selectable"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_list_box_row_set_selectable" gtk_list_box_row_set_selectable :: 
    Ptr ListBoxRow ->                       -- row : TInterface (Name {namespace = "Gtk", name = "ListBoxRow"})
    CInt ->                                 -- selectable : TBasicType TBoolean
    IO ()

-- | Set whether the row can be selected.
listBoxRowSetSelectable ::
    (B.CallStack.HasCallStack, MonadIO m, IsListBoxRow a) =>
    a
    -- ^ /@row@/: a @GtkListBoxRow@
    -> Bool
    -- ^ /@selectable@/: 'P.True' to mark the row as selectable
    -> m ()
listBoxRowSetSelectable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListBoxRow a) =>
a -> Bool -> m ()
listBoxRowSetSelectable a
row Bool
selectable = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListBoxRow
row' <- a -> IO (Ptr ListBoxRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
row
    let selectable' :: CInt
selectable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
selectable
    Ptr ListBoxRow -> CInt -> IO ()
gtk_list_box_row_set_selectable Ptr ListBoxRow
row' CInt
selectable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
row
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ListBoxRowSetSelectableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsListBoxRow a) => O.OverloadedMethod ListBoxRowSetSelectableMethodInfo a signature where
    overloadedMethod = listBoxRowSetSelectable

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


#endif