{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Gtk.Objects.CellRenderer.CellRenderer' is a base class of a set of objects used for
-- rendering a cell to a t'GI.Cairo.Structs.Context.Context'.  These objects are used primarily by
-- the t'GI.Gtk.Objects.TreeView.TreeView' widget, though they aren’t tied to them in any
-- specific way.  It is worth noting that t'GI.Gtk.Objects.CellRenderer.CellRenderer' is not a
-- t'GI.Gtk.Objects.Widget.Widget' and cannot be treated as such.
-- 
-- The primary use of a t'GI.Gtk.Objects.CellRenderer.CellRenderer' is for drawing a certain graphical
-- elements on a t'GI.Cairo.Structs.Context.Context'. Typically, one cell renderer is used to
-- draw many cells on the screen.  To this extent, it isn’t expected that a
-- CellRenderer keep any permanent state around.  Instead, any state is set
-- just prior to use using @/GObjects/@ property system.  Then, the
-- cell is measured using 'GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredSize'. Finally, the cell
-- is rendered in the correct location using 'GI.Gtk.Objects.CellRenderer.cellRendererSnapshot'.
-- 
-- There are a number of rules that must be followed when writing a new
-- t'GI.Gtk.Objects.CellRenderer.CellRenderer'.  First and foremost, it’s important that a certain set
-- of properties will always yield a cell renderer of the same size,
-- barring a style change. The t'GI.Gtk.Objects.CellRenderer.CellRenderer' also has a number of
-- generic properties that are expected to be honored by all children.
-- 
-- Beyond merely rendering a cell, cell renderers can optionally
-- provide active user interface elements. A cell renderer can be
-- “activatable” like t'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle',
-- which toggles when it gets activated by a mouse click, or it can be
-- “editable” like t'GI.Gtk.Objects.CellRendererText.CellRendererText', which
-- allows the user to edit the text using a widget implementing the
-- t'GI.Gtk.Interfaces.CellEditable.CellEditable' interface, e.g. t'GI.Gtk.Objects.Entry.Entry'.
-- To make a cell renderer activatable or editable, you have to
-- implement the t'GI.Gtk.Structs.CellRendererClass.CellRendererClass'.@/activate/@ or
-- t'GI.Gtk.Structs.CellRendererClass.CellRendererClass'.@/start_editing/@ virtual functions, respectively.
-- 
-- Many properties of t'GI.Gtk.Objects.CellRenderer.CellRenderer' and its subclasses have a
-- corresponding “set” property, e.g. “cell-background-set” corresponds
-- to “cell-background”. These “set” properties reflect whether a property
-- has been set or not. You should not set them independently.

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

module GI.Gtk.Objects.CellRenderer
    ( 

-- * Exported types
    CellRenderer(..)                        ,
    IsCellRenderer                          ,
    toCellRenderer                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [activate]("GI.Gtk.Objects.CellRenderer#g:method:activate"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isActivatable]("GI.Gtk.Objects.CellRenderer#g:method:isActivatable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [snapshot]("GI.Gtk.Objects.CellRenderer#g:method:snapshot"), [startEditing]("GI.Gtk.Objects.CellRenderer#g:method:startEditing"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [stopEditing]("GI.Gtk.Objects.CellRenderer#g:method:stopEditing"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAlignedArea]("GI.Gtk.Objects.CellRenderer#g:method:getAlignedArea"), [getAlignment]("GI.Gtk.Objects.CellRenderer#g:method:getAlignment"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getFixedSize]("GI.Gtk.Objects.CellRenderer#g:method:getFixedSize"), [getIsExpanded]("GI.Gtk.Objects.CellRenderer#g:method:getIsExpanded"), [getIsExpander]("GI.Gtk.Objects.CellRenderer#g:method:getIsExpander"), [getPadding]("GI.Gtk.Objects.CellRenderer#g:method:getPadding"), [getPreferredHeight]("GI.Gtk.Objects.CellRenderer#g:method:getPreferredHeight"), [getPreferredHeightForWidth]("GI.Gtk.Objects.CellRenderer#g:method:getPreferredHeightForWidth"), [getPreferredSize]("GI.Gtk.Objects.CellRenderer#g:method:getPreferredSize"), [getPreferredWidth]("GI.Gtk.Objects.CellRenderer#g:method:getPreferredWidth"), [getPreferredWidthForHeight]("GI.Gtk.Objects.CellRenderer#g:method:getPreferredWidthForHeight"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRequestMode]("GI.Gtk.Objects.CellRenderer#g:method:getRequestMode"), [getSensitive]("GI.Gtk.Objects.CellRenderer#g:method:getSensitive"), [getState]("GI.Gtk.Objects.CellRenderer#g:method:getState"), [getVisible]("GI.Gtk.Objects.CellRenderer#g:method:getVisible").
-- 
-- ==== Setters
-- [setAlignment]("GI.Gtk.Objects.CellRenderer#g:method:setAlignment"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFixedSize]("GI.Gtk.Objects.CellRenderer#g:method:setFixedSize"), [setIsExpanded]("GI.Gtk.Objects.CellRenderer#g:method:setIsExpanded"), [setIsExpander]("GI.Gtk.Objects.CellRenderer#g:method:setIsExpander"), [setPadding]("GI.Gtk.Objects.CellRenderer#g:method:setPadding"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSensitive]("GI.Gtk.Objects.CellRenderer#g:method:setSensitive"), [setVisible]("GI.Gtk.Objects.CellRenderer#g:method:setVisible").

#if defined(ENABLE_OVERLOADING)
    ResolveCellRendererMethod               ,
#endif

-- ** activate #method:activate#

#if defined(ENABLE_OVERLOADING)
    CellRendererActivateMethodInfo          ,
#endif
    cellRendererActivate                    ,


-- ** getAlignedArea #method:getAlignedArea#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetAlignedAreaMethodInfo    ,
#endif
    cellRendererGetAlignedArea              ,


-- ** getAlignment #method:getAlignment#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetAlignmentMethodInfo      ,
#endif
    cellRendererGetAlignment                ,


-- ** getFixedSize #method:getFixedSize#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetFixedSizeMethodInfo      ,
#endif
    cellRendererGetFixedSize                ,


-- ** getIsExpanded #method:getIsExpanded#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetIsExpandedMethodInfo     ,
#endif
    cellRendererGetIsExpanded               ,


-- ** getIsExpander #method:getIsExpander#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetIsExpanderMethodInfo     ,
#endif
    cellRendererGetIsExpander               ,


-- ** getPadding #method:getPadding#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetPaddingMethodInfo        ,
#endif
    cellRendererGetPadding                  ,


-- ** getPreferredHeight #method:getPreferredHeight#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetPreferredHeightMethodInfo,
#endif
    cellRendererGetPreferredHeight          ,


-- ** getPreferredHeightForWidth #method:getPreferredHeightForWidth#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetPreferredHeightForWidthMethodInfo,
#endif
    cellRendererGetPreferredHeightForWidth  ,


-- ** getPreferredSize #method:getPreferredSize#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetPreferredSizeMethodInfo  ,
#endif
    cellRendererGetPreferredSize            ,


-- ** getPreferredWidth #method:getPreferredWidth#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetPreferredWidthMethodInfo ,
#endif
    cellRendererGetPreferredWidth           ,


-- ** getPreferredWidthForHeight #method:getPreferredWidthForHeight#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetPreferredWidthForHeightMethodInfo,
#endif
    cellRendererGetPreferredWidthForHeight  ,


-- ** getRequestMode #method:getRequestMode#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetRequestModeMethodInfo    ,
#endif
    cellRendererGetRequestMode              ,


-- ** getSensitive #method:getSensitive#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetSensitiveMethodInfo      ,
#endif
    cellRendererGetSensitive                ,


-- ** getState #method:getState#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetStateMethodInfo          ,
#endif
    cellRendererGetState                    ,


-- ** getVisible #method:getVisible#

#if defined(ENABLE_OVERLOADING)
    CellRendererGetVisibleMethodInfo        ,
#endif
    cellRendererGetVisible                  ,


-- ** isActivatable #method:isActivatable#

#if defined(ENABLE_OVERLOADING)
    CellRendererIsActivatableMethodInfo     ,
#endif
    cellRendererIsActivatable               ,


-- ** setAlignment #method:setAlignment#

#if defined(ENABLE_OVERLOADING)
    CellRendererSetAlignmentMethodInfo      ,
#endif
    cellRendererSetAlignment                ,


-- ** setFixedSize #method:setFixedSize#

#if defined(ENABLE_OVERLOADING)
    CellRendererSetFixedSizeMethodInfo      ,
#endif
    cellRendererSetFixedSize                ,


-- ** setIsExpanded #method:setIsExpanded#

#if defined(ENABLE_OVERLOADING)
    CellRendererSetIsExpandedMethodInfo     ,
#endif
    cellRendererSetIsExpanded               ,


-- ** setIsExpander #method:setIsExpander#

#if defined(ENABLE_OVERLOADING)
    CellRendererSetIsExpanderMethodInfo     ,
#endif
    cellRendererSetIsExpander               ,


-- ** setPadding #method:setPadding#

#if defined(ENABLE_OVERLOADING)
    CellRendererSetPaddingMethodInfo        ,
#endif
    cellRendererSetPadding                  ,


-- ** setSensitive #method:setSensitive#

#if defined(ENABLE_OVERLOADING)
    CellRendererSetSensitiveMethodInfo      ,
#endif
    cellRendererSetSensitive                ,


-- ** setVisible #method:setVisible#

#if defined(ENABLE_OVERLOADING)
    CellRendererSetVisibleMethodInfo        ,
#endif
    cellRendererSetVisible                  ,


-- ** snapshot #method:snapshot#

#if defined(ENABLE_OVERLOADING)
    CellRendererSnapshotMethodInfo          ,
#endif
    cellRendererSnapshot                    ,


-- ** startEditing #method:startEditing#

#if defined(ENABLE_OVERLOADING)
    CellRendererStartEditingMethodInfo      ,
#endif
    cellRendererStartEditing                ,


-- ** stopEditing #method:stopEditing#

#if defined(ENABLE_OVERLOADING)
    CellRendererStopEditingMethodInfo       ,
#endif
    cellRendererStopEditing                 ,




 -- * Properties


-- ** cellBackground #attr:cellBackground#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererCellBackgroundPropertyInfo  ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererCellBackground              ,
#endif
    clearCellRendererCellBackground         ,
    constructCellRendererCellBackground     ,
    setCellRendererCellBackground           ,


-- ** cellBackgroundRgba #attr:cellBackgroundRgba#
-- | Cell background as a t'GI.Gdk.Structs.RGBA.RGBA'

#if defined(ENABLE_OVERLOADING)
    CellRendererCellBackgroundRgbaPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererCellBackgroundRgba          ,
#endif
    clearCellRendererCellBackgroundRgba     ,
    constructCellRendererCellBackgroundRgba ,
    getCellRendererCellBackgroundRgba       ,
    setCellRendererCellBackgroundRgba       ,


-- ** cellBackgroundSet #attr:cellBackgroundSet#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererCellBackgroundSetPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererCellBackgroundSet           ,
#endif
    constructCellRendererCellBackgroundSet  ,
    getCellRendererCellBackgroundSet        ,
    setCellRendererCellBackgroundSet        ,


-- ** editing #attr:editing#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererEditingPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererEditing                     ,
#endif
    getCellRendererEditing                  ,


-- ** height #attr:height#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererHeightPropertyInfo          ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererHeight                      ,
#endif
    constructCellRendererHeight             ,
    getCellRendererHeight                   ,
    setCellRendererHeight                   ,


-- ** isExpanded #attr:isExpanded#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererIsExpandedPropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererIsExpanded                  ,
#endif
    constructCellRendererIsExpanded         ,
    getCellRendererIsExpanded               ,
    setCellRendererIsExpanded               ,


-- ** isExpander #attr:isExpander#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererIsExpanderPropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererIsExpander                  ,
#endif
    constructCellRendererIsExpander         ,
    getCellRendererIsExpander               ,
    setCellRendererIsExpander               ,


-- ** mode #attr:mode#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererModePropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererMode                        ,
#endif
    constructCellRendererMode               ,
    getCellRendererMode                     ,
    setCellRendererMode                     ,


-- ** sensitive #attr:sensitive#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererSensitivePropertyInfo       ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererSensitive                   ,
#endif
    constructCellRendererSensitive          ,
    getCellRendererSensitive                ,
    setCellRendererSensitive                ,


-- ** visible #attr:visible#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererVisiblePropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererVisible                     ,
#endif
    constructCellRendererVisible            ,
    getCellRendererVisible                  ,
    setCellRendererVisible                  ,


-- ** width #attr:width#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererWidthPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererWidth                       ,
#endif
    constructCellRendererWidth              ,
    getCellRendererWidth                    ,
    setCellRendererWidth                    ,


-- ** xalign #attr:xalign#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererXalignPropertyInfo          ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererXalign                      ,
#endif
    constructCellRendererXalign             ,
    getCellRendererXalign                   ,
    setCellRendererXalign                   ,


-- ** xpad #attr:xpad#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererXpadPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererXpad                        ,
#endif
    constructCellRendererXpad               ,
    getCellRendererXpad                     ,
    setCellRendererXpad                     ,


-- ** yalign #attr:yalign#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererYalignPropertyInfo          ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererYalign                      ,
#endif
    constructCellRendererYalign             ,
    getCellRendererYalign                   ,
    setCellRendererYalign                   ,


-- ** ypad #attr:ypad#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    CellRendererYpadPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    cellRendererYpad                        ,
#endif
    constructCellRendererYpad               ,
    getCellRendererYpad                     ,
    setCellRendererYpad                     ,




 -- * Signals


-- ** editingCanceled #signal:editingCanceled#

    C_CellRendererEditingCanceledCallback   ,
    CellRendererEditingCanceledCallback     ,
#if defined(ENABLE_OVERLOADING)
    CellRendererEditingCanceledSignalInfo   ,
#endif
    afterCellRendererEditingCanceled        ,
    genClosure_CellRendererEditingCanceled  ,
    mk_CellRendererEditingCanceledCallback  ,
    noCellRendererEditingCanceledCallback   ,
    onCellRendererEditingCanceled           ,
    wrap_CellRendererEditingCanceledCallback,


-- ** editingStarted #signal:editingStarted#

    C_CellRendererEditingStartedCallback    ,
    CellRendererEditingStartedCallback      ,
#if defined(ENABLE_OVERLOADING)
    CellRendererEditingStartedSignalInfo    ,
#endif
    afterCellRendererEditingStarted         ,
    genClosure_CellRendererEditingStarted   ,
    mk_CellRendererEditingStartedCallback   ,
    noCellRendererEditingStartedCallback    ,
    onCellRendererEditingStarted            ,
    wrap_CellRendererEditingStartedCallback ,




    ) 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.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 qualified GI.Gdk.Objects.Event as Gdk.Event
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.CellEditable as Gtk.CellEditable
import {-# SOURCE #-} qualified GI.Gtk.Objects.Snapshot as Gtk.Snapshot
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition

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

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

foreign import ccall "gtk_cell_renderer_get_type"
    c_gtk_cell_renderer_get_type :: IO B.Types.GType

instance B.Types.TypedObject CellRenderer where
    glibType :: IO GType
glibType = IO GType
c_gtk_cell_renderer_get_type

instance B.Types.GObject CellRenderer

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

instance O.HasParentTypes CellRenderer
type instance O.ParentTypes CellRenderer = '[GObject.Object.Object]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveCellRendererMethod (t :: Symbol) (o :: *) :: * where
    ResolveCellRendererMethod "activate" o = CellRendererActivateMethodInfo
    ResolveCellRendererMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCellRendererMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCellRendererMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCellRendererMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCellRendererMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveCellRendererMethod "isActivatable" o = CellRendererIsActivatableMethodInfo
    ResolveCellRendererMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCellRendererMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCellRendererMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCellRendererMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCellRendererMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCellRendererMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveCellRendererMethod "snapshot" o = CellRendererSnapshotMethodInfo
    ResolveCellRendererMethod "startEditing" o = CellRendererStartEditingMethodInfo
    ResolveCellRendererMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveCellRendererMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveCellRendererMethod "stopEditing" o = CellRendererStopEditingMethodInfo
    ResolveCellRendererMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveCellRendererMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveCellRendererMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveCellRendererMethod "getAlignedArea" o = CellRendererGetAlignedAreaMethodInfo
    ResolveCellRendererMethod "getAlignment" o = CellRendererGetAlignmentMethodInfo
    ResolveCellRendererMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveCellRendererMethod "getFixedSize" o = CellRendererGetFixedSizeMethodInfo
    ResolveCellRendererMethod "getIsExpanded" o = CellRendererGetIsExpandedMethodInfo
    ResolveCellRendererMethod "getIsExpander" o = CellRendererGetIsExpanderMethodInfo
    ResolveCellRendererMethod "getPadding" o = CellRendererGetPaddingMethodInfo
    ResolveCellRendererMethod "getPreferredHeight" o = CellRendererGetPreferredHeightMethodInfo
    ResolveCellRendererMethod "getPreferredHeightForWidth" o = CellRendererGetPreferredHeightForWidthMethodInfo
    ResolveCellRendererMethod "getPreferredSize" o = CellRendererGetPreferredSizeMethodInfo
    ResolveCellRendererMethod "getPreferredWidth" o = CellRendererGetPreferredWidthMethodInfo
    ResolveCellRendererMethod "getPreferredWidthForHeight" o = CellRendererGetPreferredWidthForHeightMethodInfo
    ResolveCellRendererMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveCellRendererMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveCellRendererMethod "getRequestMode" o = CellRendererGetRequestModeMethodInfo
    ResolveCellRendererMethod "getSensitive" o = CellRendererGetSensitiveMethodInfo
    ResolveCellRendererMethod "getState" o = CellRendererGetStateMethodInfo
    ResolveCellRendererMethod "getVisible" o = CellRendererGetVisibleMethodInfo
    ResolveCellRendererMethod "setAlignment" o = CellRendererSetAlignmentMethodInfo
    ResolveCellRendererMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveCellRendererMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveCellRendererMethod "setFixedSize" o = CellRendererSetFixedSizeMethodInfo
    ResolveCellRendererMethod "setIsExpanded" o = CellRendererSetIsExpandedMethodInfo
    ResolveCellRendererMethod "setIsExpander" o = CellRendererSetIsExpanderMethodInfo
    ResolveCellRendererMethod "setPadding" o = CellRendererSetPaddingMethodInfo
    ResolveCellRendererMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCellRendererMethod "setSensitive" o = CellRendererSetSensitiveMethodInfo
    ResolveCellRendererMethod "setVisible" o = CellRendererSetVisibleMethodInfo
    ResolveCellRendererMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal CellRenderer::editing-canceled
-- | This signal gets emitted when the user cancels the process of editing a
-- cell.  For example, an editable cell renderer could be written to cancel
-- editing when the user presses Escape.
-- 
-- See also: 'GI.Gtk.Objects.CellRenderer.cellRendererStopEditing'.
type CellRendererEditingCanceledCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `CellRendererEditingCanceledCallback`@.
noCellRendererEditingCanceledCallback :: Maybe CellRendererEditingCanceledCallback
noCellRendererEditingCanceledCallback :: Maybe (IO ())
noCellRendererEditingCanceledCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_CellRendererEditingCanceledCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_CellRendererEditingCanceled :: MonadIO m => CellRendererEditingCanceledCallback -> m (GClosure C_CellRendererEditingCanceledCallback)
genClosure_CellRendererEditingCanceled :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_CellRendererEditingCanceledCallback)
genClosure_CellRendererEditingCanceled IO ()
cb = IO (GClosure C_CellRendererEditingCanceledCallback)
-> m (GClosure C_CellRendererEditingCanceledCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CellRendererEditingCanceledCallback)
 -> m (GClosure C_CellRendererEditingCanceledCallback))
-> IO (GClosure C_CellRendererEditingCanceledCallback)
-> m (GClosure C_CellRendererEditingCanceledCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CellRendererEditingCanceledCallback
cb' = IO () -> C_CellRendererEditingCanceledCallback
wrap_CellRendererEditingCanceledCallback IO ()
cb
    C_CellRendererEditingCanceledCallback
-> IO (FunPtr C_CellRendererEditingCanceledCallback)
mk_CellRendererEditingCanceledCallback C_CellRendererEditingCanceledCallback
cb' IO (FunPtr C_CellRendererEditingCanceledCallback)
-> (FunPtr C_CellRendererEditingCanceledCallback
    -> IO (GClosure C_CellRendererEditingCanceledCallback))
-> IO (GClosure C_CellRendererEditingCanceledCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CellRendererEditingCanceledCallback
-> IO (GClosure C_CellRendererEditingCanceledCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `CellRendererEditingCanceledCallback` into a `C_CellRendererEditingCanceledCallback`.
wrap_CellRendererEditingCanceledCallback ::
    CellRendererEditingCanceledCallback ->
    C_CellRendererEditingCanceledCallback
wrap_CellRendererEditingCanceledCallback :: IO () -> C_CellRendererEditingCanceledCallback
wrap_CellRendererEditingCanceledCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [editingCanceled](#signal:editingCanceled) 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' cellRenderer #editingCanceled callback
-- @
-- 
-- 
onCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingCanceledCallback -> m SignalHandlerId
onCellRendererEditingCanceled :: forall a (m :: * -> *).
(IsCellRenderer a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onCellRendererEditingCanceled a
obj 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 cb' :: C_CellRendererEditingCanceledCallback
cb' = IO () -> C_CellRendererEditingCanceledCallback
wrap_CellRendererEditingCanceledCallback IO ()
cb
    FunPtr C_CellRendererEditingCanceledCallback
cb'' <- C_CellRendererEditingCanceledCallback
-> IO (FunPtr C_CellRendererEditingCanceledCallback)
mk_CellRendererEditingCanceledCallback C_CellRendererEditingCanceledCallback
cb'
    a
-> Text
-> FunPtr C_CellRendererEditingCanceledCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"editing-canceled" FunPtr C_CellRendererEditingCanceledCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [editingCanceled](#signal:editingCanceled) 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' cellRenderer #editingCanceled callback
-- @
-- 
-- 
afterCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingCanceledCallback -> m SignalHandlerId
afterCellRendererEditingCanceled :: forall a (m :: * -> *).
(IsCellRenderer a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterCellRendererEditingCanceled a
obj 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 cb' :: C_CellRendererEditingCanceledCallback
cb' = IO () -> C_CellRendererEditingCanceledCallback
wrap_CellRendererEditingCanceledCallback IO ()
cb
    FunPtr C_CellRendererEditingCanceledCallback
cb'' <- C_CellRendererEditingCanceledCallback
-> IO (FunPtr C_CellRendererEditingCanceledCallback)
mk_CellRendererEditingCanceledCallback C_CellRendererEditingCanceledCallback
cb'
    a
-> Text
-> FunPtr C_CellRendererEditingCanceledCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"editing-canceled" FunPtr C_CellRendererEditingCanceledCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data CellRendererEditingCanceledSignalInfo
instance SignalInfo CellRendererEditingCanceledSignalInfo where
    type HaskellCallbackType CellRendererEditingCanceledSignalInfo = CellRendererEditingCanceledCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_CellRendererEditingCanceledCallback cb
        cb'' <- mk_CellRendererEditingCanceledCallback cb'
        connectSignalFunPtr obj "editing-canceled" cb'' connectMode detail

#endif

-- signal CellRenderer::editing-started
-- | This signal gets emitted when a cell starts to be edited.
-- The intended use of this signal is to do special setup
-- on /@editable@/, e.g. adding a t'GI.Gtk.Objects.EntryCompletion.EntryCompletion' or setting
-- up additional columns in a t'GI.Gtk.Objects.ComboBox.ComboBox'.
-- 
-- See 'GI.Gtk.Interfaces.CellEditable.cellEditableStartEditing' for information on the lifecycle of
-- the /@editable@/ and a way to do setup that doesn’t depend on the /@renderer@/.
-- 
-- Note that GTK doesn\'t guarantee that cell renderers will
-- continue to use the same kind of widget for editing in future
-- releases, therefore you should check the type of /@editable@/
-- before doing any specific setup, as in the following example:
-- 
-- === /C code/
-- >
-- >static void
-- >text_editing_started (GtkCellRenderer *cell,
-- >                      GtkCellEditable *editable,
-- >                      const char      *path,
-- >                      gpointer         data)
-- >{
-- >  if (GTK_IS_ENTRY (editable))
-- >    {
-- >      GtkEntry *entry = GTK_ENTRY (editable);
-- >      
-- >      // ... create a GtkEntryCompletion
-- >      
-- >      gtk_entry_set_completion (entry, completion);
-- >    }
-- >}
type CellRendererEditingStartedCallback =
    Gtk.CellEditable.CellEditable
    -- ^ /@editable@/: the t'GI.Gtk.Interfaces.CellEditable.CellEditable'
    -> T.Text
    -- ^ /@path@/: the path identifying the edited cell
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `CellRendererEditingStartedCallback`@.
noCellRendererEditingStartedCallback :: Maybe CellRendererEditingStartedCallback
noCellRendererEditingStartedCallback :: Maybe CellRendererEditingStartedCallback
noCellRendererEditingStartedCallback = Maybe CellRendererEditingStartedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_CellRendererEditingStartedCallback =
    Ptr () ->                               -- object
    Ptr Gtk.CellEditable.CellEditable ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_CellRendererEditingStarted :: MonadIO m => CellRendererEditingStartedCallback -> m (GClosure C_CellRendererEditingStartedCallback)
genClosure_CellRendererEditingStarted :: forall (m :: * -> *).
MonadIO m =>
CellRendererEditingStartedCallback
-> m (GClosure C_CellRendererEditingStartedCallback)
genClosure_CellRendererEditingStarted CellRendererEditingStartedCallback
cb = IO (GClosure C_CellRendererEditingStartedCallback)
-> m (GClosure C_CellRendererEditingStartedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CellRendererEditingStartedCallback)
 -> m (GClosure C_CellRendererEditingStartedCallback))
-> IO (GClosure C_CellRendererEditingStartedCallback)
-> m (GClosure C_CellRendererEditingStartedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CellRendererEditingStartedCallback
cb' = CellRendererEditingStartedCallback
-> C_CellRendererEditingStartedCallback
wrap_CellRendererEditingStartedCallback CellRendererEditingStartedCallback
cb
    C_CellRendererEditingStartedCallback
-> IO (FunPtr C_CellRendererEditingStartedCallback)
mk_CellRendererEditingStartedCallback C_CellRendererEditingStartedCallback
cb' IO (FunPtr C_CellRendererEditingStartedCallback)
-> (FunPtr C_CellRendererEditingStartedCallback
    -> IO (GClosure C_CellRendererEditingStartedCallback))
-> IO (GClosure C_CellRendererEditingStartedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CellRendererEditingStartedCallback
-> IO (GClosure C_CellRendererEditingStartedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `CellRendererEditingStartedCallback` into a `C_CellRendererEditingStartedCallback`.
wrap_CellRendererEditingStartedCallback ::
    CellRendererEditingStartedCallback ->
    C_CellRendererEditingStartedCallback
wrap_CellRendererEditingStartedCallback :: CellRendererEditingStartedCallback
-> C_CellRendererEditingStartedCallback
wrap_CellRendererEditingStartedCallback CellRendererEditingStartedCallback
_cb Ptr ()
_ Ptr CellEditable
editable CString
path Ptr ()
_ = do
    CellEditable
editable' <- ((ManagedPtr CellEditable -> CellEditable)
-> Ptr CellEditable -> IO CellEditable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CellEditable -> CellEditable
Gtk.CellEditable.CellEditable) Ptr CellEditable
editable
    Text
path' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
path
    CellRendererEditingStartedCallback
_cb  CellEditable
editable' Text
path'


-- | Connect a signal handler for the [editingStarted](#signal:editingStarted) 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' cellRenderer #editingStarted callback
-- @
-- 
-- 
onCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingStartedCallback -> m SignalHandlerId
onCellRendererEditingStarted :: forall a (m :: * -> *).
(IsCellRenderer a, MonadIO m) =>
a -> CellRendererEditingStartedCallback -> m SignalHandlerId
onCellRendererEditingStarted a
obj CellRendererEditingStartedCallback
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 cb' :: C_CellRendererEditingStartedCallback
cb' = CellRendererEditingStartedCallback
-> C_CellRendererEditingStartedCallback
wrap_CellRendererEditingStartedCallback CellRendererEditingStartedCallback
cb
    FunPtr C_CellRendererEditingStartedCallback
cb'' <- C_CellRendererEditingStartedCallback
-> IO (FunPtr C_CellRendererEditingStartedCallback)
mk_CellRendererEditingStartedCallback C_CellRendererEditingStartedCallback
cb'
    a
-> Text
-> FunPtr C_CellRendererEditingStartedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"editing-started" FunPtr C_CellRendererEditingStartedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [editingStarted](#signal:editingStarted) 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' cellRenderer #editingStarted callback
-- @
-- 
-- 
afterCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingStartedCallback -> m SignalHandlerId
afterCellRendererEditingStarted :: forall a (m :: * -> *).
(IsCellRenderer a, MonadIO m) =>
a -> CellRendererEditingStartedCallback -> m SignalHandlerId
afterCellRendererEditingStarted a
obj CellRendererEditingStartedCallback
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 cb' :: C_CellRendererEditingStartedCallback
cb' = CellRendererEditingStartedCallback
-> C_CellRendererEditingStartedCallback
wrap_CellRendererEditingStartedCallback CellRendererEditingStartedCallback
cb
    FunPtr C_CellRendererEditingStartedCallback
cb'' <- C_CellRendererEditingStartedCallback
-> IO (FunPtr C_CellRendererEditingStartedCallback)
mk_CellRendererEditingStartedCallback C_CellRendererEditingStartedCallback
cb'
    a
-> Text
-> FunPtr C_CellRendererEditingStartedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"editing-started" FunPtr C_CellRendererEditingStartedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data CellRendererEditingStartedSignalInfo
instance SignalInfo CellRendererEditingStartedSignalInfo where
    type HaskellCallbackType CellRendererEditingStartedSignalInfo = CellRendererEditingStartedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_CellRendererEditingStartedCallback cb
        cb'' <- mk_CellRendererEditingStartedCallback cb'
        connectSignalFunPtr obj "editing-started" cb'' connectMode detail

#endif

-- VVV Prop "cell-background"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

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

-- | Set the value of the “@cell-background@” 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' #cellBackground
-- @
clearCellRendererCellBackground :: (MonadIO m, IsCellRenderer o) => o -> m ()
clearCellRendererCellBackground :: forall (m :: * -> *) o. (MonadIO m, IsCellRenderer o) => o -> m ()
clearCellRendererCellBackground 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 Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"cell-background" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data CellRendererCellBackgroundPropertyInfo
instance AttrInfo CellRendererCellBackgroundPropertyInfo where
    type AttrAllowedOps CellRendererCellBackgroundPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrClear]
    type AttrBaseTypeConstraint CellRendererCellBackgroundPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererCellBackgroundPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint CellRendererCellBackgroundPropertyInfo = (~) T.Text
    type AttrTransferType CellRendererCellBackgroundPropertyInfo = T.Text
    type AttrGetType CellRendererCellBackgroundPropertyInfo = ()
    type AttrLabel CellRendererCellBackgroundPropertyInfo = "cell-background"
    type AttrOrigin CellRendererCellBackgroundPropertyInfo = CellRenderer
    attrGet = undefined
    attrSet = setCellRendererCellBackground
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererCellBackground
    attrClear = clearCellRendererCellBackground
#endif

-- VVV Prop "cell-background-rgba"
   -- Type: TInterface (Name {namespace = "Gdk", name = "RGBA"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@cell-background-rgba@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' cellRenderer #cellBackgroundRgba
-- @
getCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> m (Maybe Gdk.RGBA.RGBA)
getCellRendererCellBackgroundRgba :: forall (m :: * -> *) o.
(MonadIO m, IsCellRenderer o) =>
o -> m (Maybe RGBA)
getCellRendererCellBackgroundRgba o
obj = IO (Maybe RGBA) -> m (Maybe RGBA)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe RGBA) -> m (Maybe RGBA))
-> IO (Maybe RGBA) -> m (Maybe RGBA)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr RGBA -> RGBA) -> IO (Maybe RGBA)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"cell-background-rgba" ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA

-- | Set the value of the “@cell-background-rgba@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' cellRenderer [ #cellBackgroundRgba 'Data.GI.Base.Attributes.:=' value ]
-- @
setCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> Gdk.RGBA.RGBA -> m ()
setCellRendererCellBackgroundRgba :: forall (m :: * -> *) o.
(MonadIO m, IsCellRenderer o) =>
o -> RGBA -> m ()
setCellRendererCellBackgroundRgba o
obj RGBA
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 RGBA -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"cell-background-rgba" (RGBA -> Maybe RGBA
forall a. a -> Maybe a
Just RGBA
val)

-- | Construct a `GValueConstruct` with valid value for the “@cell-background-rgba@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCellRendererCellBackgroundRgba :: (IsCellRenderer o, MIO.MonadIO m) => Gdk.RGBA.RGBA -> m (GValueConstruct o)
constructCellRendererCellBackgroundRgba :: forall o (m :: * -> *).
(IsCellRenderer o, MonadIO m) =>
RGBA -> m (GValueConstruct o)
constructCellRendererCellBackgroundRgba RGBA
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 RGBA -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"cell-background-rgba" (RGBA -> Maybe RGBA
forall a. a -> Maybe a
P.Just RGBA
val)

-- | Set the value of the “@cell-background-rgba@” 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' #cellBackgroundRgba
-- @
clearCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> m ()
clearCellRendererCellBackgroundRgba :: forall (m :: * -> *) o. (MonadIO m, IsCellRenderer o) => o -> m ()
clearCellRendererCellBackgroundRgba 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 RGBA -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"cell-background-rgba" (Maybe RGBA
forall a. Maybe a
Nothing :: Maybe Gdk.RGBA.RGBA)

#if defined(ENABLE_OVERLOADING)
data CellRendererCellBackgroundRgbaPropertyInfo
instance AttrInfo CellRendererCellBackgroundRgbaPropertyInfo where
    type AttrAllowedOps CellRendererCellBackgroundRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint CellRendererCellBackgroundRgbaPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererCellBackgroundRgbaPropertyInfo = (~) Gdk.RGBA.RGBA
    type AttrTransferTypeConstraint CellRendererCellBackgroundRgbaPropertyInfo = (~) Gdk.RGBA.RGBA
    type AttrTransferType CellRendererCellBackgroundRgbaPropertyInfo = Gdk.RGBA.RGBA
    type AttrGetType CellRendererCellBackgroundRgbaPropertyInfo = (Maybe Gdk.RGBA.RGBA)
    type AttrLabel CellRendererCellBackgroundRgbaPropertyInfo = "cell-background-rgba"
    type AttrOrigin CellRendererCellBackgroundRgbaPropertyInfo = CellRenderer
    attrGet = getCellRendererCellBackgroundRgba
    attrSet = setCellRendererCellBackgroundRgba
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererCellBackgroundRgba
    attrClear = clearCellRendererCellBackgroundRgba
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data CellRendererCellBackgroundSetPropertyInfo
instance AttrInfo CellRendererCellBackgroundSetPropertyInfo where
    type AttrAllowedOps CellRendererCellBackgroundSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CellRendererCellBackgroundSetPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererCellBackgroundSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint CellRendererCellBackgroundSetPropertyInfo = (~) Bool
    type AttrTransferType CellRendererCellBackgroundSetPropertyInfo = Bool
    type AttrGetType CellRendererCellBackgroundSetPropertyInfo = Bool
    type AttrLabel CellRendererCellBackgroundSetPropertyInfo = "cell-background-set"
    type AttrOrigin CellRendererCellBackgroundSetPropertyInfo = CellRenderer
    attrGet = getCellRendererCellBackgroundSet
    attrSet = setCellRendererCellBackgroundSet
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererCellBackgroundSet
    attrClear = undefined
#endif

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

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

#if defined(ENABLE_OVERLOADING)
data CellRendererEditingPropertyInfo
instance AttrInfo CellRendererEditingPropertyInfo where
    type AttrAllowedOps CellRendererEditingPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint CellRendererEditingPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererEditingPropertyInfo = (~) ()
    type AttrTransferTypeConstraint CellRendererEditingPropertyInfo = (~) ()
    type AttrTransferType CellRendererEditingPropertyInfo = ()
    type AttrGetType CellRendererEditingPropertyInfo = Bool
    type AttrLabel CellRendererEditingPropertyInfo = "editing"
    type AttrOrigin CellRendererEditingPropertyInfo = CellRenderer
    attrGet = getCellRendererEditing
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

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

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

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

-- | Construct a `GValueConstruct` with valid value for the “@height@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCellRendererHeight :: (IsCellRenderer o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructCellRendererHeight :: forall o (m :: * -> *).
(IsCellRenderer o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructCellRendererHeight Int32
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 -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"height" Int32
val

#if defined(ENABLE_OVERLOADING)
data CellRendererHeightPropertyInfo
instance AttrInfo CellRendererHeightPropertyInfo where
    type AttrAllowedOps CellRendererHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CellRendererHeightPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererHeightPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint CellRendererHeightPropertyInfo = (~) Int32
    type AttrTransferType CellRendererHeightPropertyInfo = Int32
    type AttrGetType CellRendererHeightPropertyInfo = Int32
    type AttrLabel CellRendererHeightPropertyInfo = "height"
    type AttrOrigin CellRendererHeightPropertyInfo = CellRenderer
    attrGet = getCellRendererHeight
    attrSet = setCellRendererHeight
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererHeight
    attrClear = undefined
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data CellRendererIsExpandedPropertyInfo
instance AttrInfo CellRendererIsExpandedPropertyInfo where
    type AttrAllowedOps CellRendererIsExpandedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CellRendererIsExpandedPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererIsExpandedPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint CellRendererIsExpandedPropertyInfo = (~) Bool
    type AttrTransferType CellRendererIsExpandedPropertyInfo = Bool
    type AttrGetType CellRendererIsExpandedPropertyInfo = Bool
    type AttrLabel CellRendererIsExpandedPropertyInfo = "is-expanded"
    type AttrOrigin CellRendererIsExpandedPropertyInfo = CellRenderer
    attrGet = getCellRendererIsExpanded
    attrSet = setCellRendererIsExpanded
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererIsExpanded
    attrClear = undefined
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data CellRendererIsExpanderPropertyInfo
instance AttrInfo CellRendererIsExpanderPropertyInfo where
    type AttrAllowedOps CellRendererIsExpanderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CellRendererIsExpanderPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererIsExpanderPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint CellRendererIsExpanderPropertyInfo = (~) Bool
    type AttrTransferType CellRendererIsExpanderPropertyInfo = Bool
    type AttrGetType CellRendererIsExpanderPropertyInfo = Bool
    type AttrLabel CellRendererIsExpanderPropertyInfo = "is-expander"
    type AttrOrigin CellRendererIsExpanderPropertyInfo = CellRenderer
    attrGet = getCellRendererIsExpander
    attrSet = setCellRendererIsExpander
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererIsExpander
    attrClear = undefined
#endif

-- VVV Prop "mode"
   -- Type: TInterface (Name {namespace = "Gtk", name = "CellRendererMode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

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

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

#if defined(ENABLE_OVERLOADING)
data CellRendererModePropertyInfo
instance AttrInfo CellRendererModePropertyInfo where
    type AttrAllowedOps CellRendererModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CellRendererModePropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererModePropertyInfo = (~) Gtk.Enums.CellRendererMode
    type AttrTransferTypeConstraint CellRendererModePropertyInfo = (~) Gtk.Enums.CellRendererMode
    type AttrTransferType CellRendererModePropertyInfo = Gtk.Enums.CellRendererMode
    type AttrGetType CellRendererModePropertyInfo = Gtk.Enums.CellRendererMode
    type AttrLabel CellRendererModePropertyInfo = "mode"
    type AttrOrigin CellRendererModePropertyInfo = CellRenderer
    attrGet = getCellRendererMode
    attrSet = setCellRendererMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererMode
    attrClear = undefined
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data CellRendererSensitivePropertyInfo
instance AttrInfo CellRendererSensitivePropertyInfo where
    type AttrAllowedOps CellRendererSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CellRendererSensitivePropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererSensitivePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint CellRendererSensitivePropertyInfo = (~) Bool
    type AttrTransferType CellRendererSensitivePropertyInfo = Bool
    type AttrGetType CellRendererSensitivePropertyInfo = Bool
    type AttrLabel CellRendererSensitivePropertyInfo = "sensitive"
    type AttrOrigin CellRendererSensitivePropertyInfo = CellRenderer
    attrGet = getCellRendererSensitive
    attrSet = setCellRendererSensitive
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererSensitive
    attrClear = undefined
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data CellRendererVisiblePropertyInfo
instance AttrInfo CellRendererVisiblePropertyInfo where
    type AttrAllowedOps CellRendererVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CellRendererVisiblePropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererVisiblePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint CellRendererVisiblePropertyInfo = (~) Bool
    type AttrTransferType CellRendererVisiblePropertyInfo = Bool
    type AttrGetType CellRendererVisiblePropertyInfo = Bool
    type AttrLabel CellRendererVisiblePropertyInfo = "visible"
    type AttrOrigin CellRendererVisiblePropertyInfo = CellRenderer
    attrGet = getCellRendererVisible
    attrSet = setCellRendererVisible
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererVisible
    attrClear = undefined
#endif

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

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

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

-- | Construct a `GValueConstruct` with valid value for the “@width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCellRendererWidth :: (IsCellRenderer o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructCellRendererWidth :: forall o (m :: * -> *).
(IsCellRenderer o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructCellRendererWidth Int32
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 -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"width" Int32
val

#if defined(ENABLE_OVERLOADING)
data CellRendererWidthPropertyInfo
instance AttrInfo CellRendererWidthPropertyInfo where
    type AttrAllowedOps CellRendererWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CellRendererWidthPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererWidthPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint CellRendererWidthPropertyInfo = (~) Int32
    type AttrTransferType CellRendererWidthPropertyInfo = Int32
    type AttrGetType CellRendererWidthPropertyInfo = Int32
    type AttrLabel CellRendererWidthPropertyInfo = "width"
    type AttrOrigin CellRendererWidthPropertyInfo = CellRenderer
    attrGet = getCellRendererWidth
    attrSet = setCellRendererWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererWidth
    attrClear = undefined
#endif

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

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

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

-- | Construct a `GValueConstruct` with valid value for the “@xalign@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCellRendererXalign :: (IsCellRenderer o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructCellRendererXalign :: forall o (m :: * -> *).
(IsCellRenderer o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructCellRendererXalign Float
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 -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"xalign" Float
val

#if defined(ENABLE_OVERLOADING)
data CellRendererXalignPropertyInfo
instance AttrInfo CellRendererXalignPropertyInfo where
    type AttrAllowedOps CellRendererXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CellRendererXalignPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererXalignPropertyInfo = (~) Float
    type AttrTransferTypeConstraint CellRendererXalignPropertyInfo = (~) Float
    type AttrTransferType CellRendererXalignPropertyInfo = Float
    type AttrGetType CellRendererXalignPropertyInfo = Float
    type AttrLabel CellRendererXalignPropertyInfo = "xalign"
    type AttrOrigin CellRendererXalignPropertyInfo = CellRenderer
    attrGet = getCellRendererXalign
    attrSet = setCellRendererXalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererXalign
    attrClear = undefined
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data CellRendererXpadPropertyInfo
instance AttrInfo CellRendererXpadPropertyInfo where
    type AttrAllowedOps CellRendererXpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CellRendererXpadPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererXpadPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint CellRendererXpadPropertyInfo = (~) Word32
    type AttrTransferType CellRendererXpadPropertyInfo = Word32
    type AttrGetType CellRendererXpadPropertyInfo = Word32
    type AttrLabel CellRendererXpadPropertyInfo = "xpad"
    type AttrOrigin CellRendererXpadPropertyInfo = CellRenderer
    attrGet = getCellRendererXpad
    attrSet = setCellRendererXpad
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererXpad
    attrClear = undefined
#endif

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

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

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

-- | Construct a `GValueConstruct` with valid value for the “@yalign@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCellRendererYalign :: (IsCellRenderer o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructCellRendererYalign :: forall o (m :: * -> *).
(IsCellRenderer o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructCellRendererYalign Float
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 -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"yalign" Float
val

#if defined(ENABLE_OVERLOADING)
data CellRendererYalignPropertyInfo
instance AttrInfo CellRendererYalignPropertyInfo where
    type AttrAllowedOps CellRendererYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CellRendererYalignPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererYalignPropertyInfo = (~) Float
    type AttrTransferTypeConstraint CellRendererYalignPropertyInfo = (~) Float
    type AttrTransferType CellRendererYalignPropertyInfo = Float
    type AttrGetType CellRendererYalignPropertyInfo = Float
    type AttrLabel CellRendererYalignPropertyInfo = "yalign"
    type AttrOrigin CellRendererYalignPropertyInfo = CellRenderer
    attrGet = getCellRendererYalign
    attrSet = setCellRendererYalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererYalign
    attrClear = undefined
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data CellRendererYpadPropertyInfo
instance AttrInfo CellRendererYpadPropertyInfo where
    type AttrAllowedOps CellRendererYpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CellRendererYpadPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererYpadPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint CellRendererYpadPropertyInfo = (~) Word32
    type AttrTransferType CellRendererYpadPropertyInfo = Word32
    type AttrGetType CellRendererYpadPropertyInfo = Word32
    type AttrLabel CellRendererYpadPropertyInfo = "ypad"
    type AttrOrigin CellRendererYpadPropertyInfo = CellRenderer
    attrGet = getCellRendererYpad
    attrSet = setCellRendererYpad
    attrTransfer _ v = do
        return v
    attrConstruct = constructCellRendererYpad
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList CellRenderer
type instance O.AttributeList CellRenderer = CellRendererAttributeList
type CellRendererAttributeList = ('[ '("cellBackground", CellRendererCellBackgroundPropertyInfo), '("cellBackgroundRgba", CellRendererCellBackgroundRgbaPropertyInfo), '("cellBackgroundSet", CellRendererCellBackgroundSetPropertyInfo), '("editing", CellRendererEditingPropertyInfo), '("height", CellRendererHeightPropertyInfo), '("isExpanded", CellRendererIsExpandedPropertyInfo), '("isExpander", CellRendererIsExpanderPropertyInfo), '("mode", CellRendererModePropertyInfo), '("sensitive", CellRendererSensitivePropertyInfo), '("visible", CellRendererVisiblePropertyInfo), '("width", CellRendererWidthPropertyInfo), '("xalign", CellRendererXalignPropertyInfo), '("xpad", CellRendererXpadPropertyInfo), '("yalign", CellRendererYalignPropertyInfo), '("ypad", CellRendererYpadPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
cellRendererCellBackground :: AttrLabelProxy "cellBackground"
cellRendererCellBackground = AttrLabelProxy

cellRendererCellBackgroundRgba :: AttrLabelProxy "cellBackgroundRgba"
cellRendererCellBackgroundRgba = AttrLabelProxy

cellRendererCellBackgroundSet :: AttrLabelProxy "cellBackgroundSet"
cellRendererCellBackgroundSet = AttrLabelProxy

cellRendererEditing :: AttrLabelProxy "editing"
cellRendererEditing = AttrLabelProxy

cellRendererHeight :: AttrLabelProxy "height"
cellRendererHeight = AttrLabelProxy

cellRendererIsExpanded :: AttrLabelProxy "isExpanded"
cellRendererIsExpanded = AttrLabelProxy

cellRendererIsExpander :: AttrLabelProxy "isExpander"
cellRendererIsExpander = AttrLabelProxy

cellRendererMode :: AttrLabelProxy "mode"
cellRendererMode = AttrLabelProxy

cellRendererSensitive :: AttrLabelProxy "sensitive"
cellRendererSensitive = AttrLabelProxy

cellRendererVisible :: AttrLabelProxy "visible"
cellRendererVisible = AttrLabelProxy

cellRendererWidth :: AttrLabelProxy "width"
cellRendererWidth = AttrLabelProxy

cellRendererXalign :: AttrLabelProxy "xalign"
cellRendererXalign = AttrLabelProxy

cellRendererXpad :: AttrLabelProxy "xpad"
cellRendererXpad = AttrLabelProxy

cellRendererYalign :: AttrLabelProxy "yalign"
cellRendererYalign = AttrLabelProxy

cellRendererYpad :: AttrLabelProxy "ypad"
cellRendererYpad = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList CellRenderer = CellRendererSignalList
type CellRendererSignalList = ('[ '("editingCanceled", CellRendererEditingCanceledSignalInfo), '("editingStarted", CellRendererEditingStartedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method CellRenderer::activate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "event"
--           , argType = TInterface Name { namespace = "Gdk" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "widget that received the event"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "widget-dependent string representation of the event location;\n   e.g. for #GtkTreeView, a string representation of #GtkTreePath"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "background_area"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "background area as passed to gtk_cell_renderer_render()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cell_area"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "cell area as passed to gtk_cell_renderer_render()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRendererState" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "render flags" , 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_cell_renderer_activate" gtk_cell_renderer_activate :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- path : TBasicType TUTF8
    Ptr Gdk.Rectangle.Rectangle ->          -- background_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Ptr Gdk.Rectangle.Rectangle ->          -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gtk", name = "CellRendererState"})
    IO CInt

-- | Passes an activate event to the cell renderer for possible processing.
-- Some cell renderers may use events; for example, t'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle'
-- toggles when it gets a mouse click.
cellRendererActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gdk.Event.IsEvent b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> b
    -- ^ /@event@/: a t'GI.Gdk.Objects.Event.Event'
    -> c
    -- ^ /@widget@/: widget that received the event
    -> T.Text
    -- ^ /@path@/: widget-dependent string representation of the event location;
    --    e.g. for t'GI.Gtk.Objects.TreeView.TreeView', a string representation of t'GI.Gtk.Structs.TreePath.TreePath'
    -> Gdk.Rectangle.Rectangle
    -- ^ /@backgroundArea@/: background area as passed to @/gtk_cell_renderer_render()/@
    -> Gdk.Rectangle.Rectangle
    -- ^ /@cellArea@/: cell area as passed to @/gtk_cell_renderer_render()/@
    -> [Gtk.Flags.CellRendererState]
    -- ^ /@flags@/: render flags
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the event was consumed\/handled
cellRendererActivate :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsCellRenderer a, IsEvent b,
 IsWidget c) =>
a
-> b
-> c
-> Text
-> Rectangle
-> Rectangle
-> [CellRendererState]
-> m Bool
cellRendererActivate a
cell b
event c
widget Text
path Rectangle
backgroundArea Rectangle
cellArea [CellRendererState]
flags = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Event
event' <- b -> IO (Ptr Event)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
event
    Ptr Widget
widget' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
widget
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr Rectangle
backgroundArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
backgroundArea
    Ptr Rectangle
cellArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
cellArea
    let flags' :: CUInt
flags' = [CellRendererState] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [CellRendererState]
flags
    CInt
result <- Ptr CellRenderer
-> Ptr Event
-> Ptr Widget
-> CString
-> Ptr Rectangle
-> Ptr Rectangle
-> CUInt
-> IO CInt
gtk_cell_renderer_activate Ptr CellRenderer
cell' Ptr Event
event' Ptr Widget
widget' CString
path' Ptr Rectangle
backgroundArea' Ptr Rectangle
cellArea' CUInt
flags'
    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
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
event
    c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
widget
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
backgroundArea
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
cellArea
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CellRendererActivateMethodInfo
instance (signature ~ (b -> c -> T.Text -> Gdk.Rectangle.Rectangle -> Gdk.Rectangle.Rectangle -> [Gtk.Flags.CellRendererState] -> m Bool), MonadIO m, IsCellRenderer a, Gdk.Event.IsEvent b, Gtk.Widget.IsWidget c) => O.OverloadedMethod CellRendererActivateMethodInfo a signature where
    overloadedMethod = cellRendererActivate

instance O.OverloadedMethodInfo CellRendererActivateMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererActivate",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererActivate"
        }


#endif

-- method CellRenderer::get_aligned_area
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GtkWidget this cell will be rendering to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRendererState" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "render flags" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cell_area"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "cell area which would be passed to gtk_cell_renderer_render()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "aligned_area"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the return location for the space inside @cell_area\n               that would actually be used to render."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_aligned_area" gtk_cell_renderer_get_aligned_area :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gtk", name = "CellRendererState"})
    Ptr Gdk.Rectangle.Rectangle ->          -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Ptr Gdk.Rectangle.Rectangle ->          -- aligned_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO ()

-- | Gets the aligned area used by /@cell@/ inside /@cellArea@/. Used for finding
-- the appropriate edit and focus rectangle.
cellRendererGetAlignedArea ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer' instance
    -> b
    -- ^ /@widget@/: the t'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to
    -> [Gtk.Flags.CellRendererState]
    -- ^ /@flags@/: render flags
    -> Gdk.Rectangle.Rectangle
    -- ^ /@cellArea@/: cell area which would be passed to @/gtk_cell_renderer_render()/@
    -> m (Gdk.Rectangle.Rectangle)
cellRendererGetAlignedArea :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) =>
a -> b -> [CellRendererState] -> Rectangle -> m Rectangle
cellRendererGetAlignedArea a
cell b
widget [CellRendererState]
flags Rectangle
cellArea = IO Rectangle -> m Rectangle
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rectangle -> m Rectangle) -> IO Rectangle -> m Rectangle
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    let flags' :: CUInt
flags' = [CellRendererState] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [CellRendererState]
flags
    Ptr Rectangle
cellArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
cellArea
    Ptr Rectangle
alignedArea <- Int -> IO (Ptr Rectangle)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Gdk.Rectangle.Rectangle)
    Ptr CellRenderer
-> Ptr Widget -> CUInt -> Ptr Rectangle -> Ptr Rectangle -> IO ()
gtk_cell_renderer_get_aligned_area Ptr CellRenderer
cell' Ptr Widget
widget' CUInt
flags' Ptr Rectangle
cellArea' Ptr Rectangle
alignedArea
    Rectangle
alignedArea' <- ((ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> IO Rectangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rectangle -> Rectangle
Gdk.Rectangle.Rectangle) Ptr Rectangle
alignedArea
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
cellArea
    Rectangle -> IO Rectangle
forall (m :: * -> *) a. Monad m => a -> m a
return Rectangle
alignedArea'

#if defined(ENABLE_OVERLOADING)
data CellRendererGetAlignedAreaMethodInfo
instance (signature ~ (b -> [Gtk.Flags.CellRendererState] -> Gdk.Rectangle.Rectangle -> m (Gdk.Rectangle.Rectangle)), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.OverloadedMethod CellRendererGetAlignedAreaMethodInfo a signature where
    overloadedMethod = cellRendererGetAlignedArea

instance O.OverloadedMethodInfo CellRendererGetAlignedAreaMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetAlignedArea",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetAlignedArea"
        }


#endif

-- method CellRenderer::get_alignment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xalign"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "location to fill in with the x alignment of the cell, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "yalign"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "location to fill in with the y alignment of the cell, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_alignment" gtk_cell_renderer_get_alignment :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr CFloat ->                           -- xalign : TBasicType TFloat
    Ptr CFloat ->                           -- yalign : TBasicType TFloat
    IO ()

-- | Fills in /@xalign@/ and /@yalign@/ with the appropriate values of /@cell@/.
cellRendererGetAlignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m ((Float, Float))
cellRendererGetAlignment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> m (Float, Float)
cellRendererGetAlignment a
cell = IO (Float, Float) -> m (Float, Float)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr CFloat
xalign <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
yalign <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CellRenderer -> Ptr CFloat -> Ptr CFloat -> IO ()
gtk_cell_renderer_get_alignment Ptr CellRenderer
cell' Ptr CFloat
xalign Ptr CFloat
yalign
    CFloat
xalign' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
xalign
    let xalign'' :: Float
xalign'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
xalign'
    CFloat
yalign' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
yalign
    let yalign'' :: Float
yalign'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
yalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
xalign
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
yalign
    (Float, Float) -> IO (Float, Float)
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
xalign'', Float
yalign'')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetAlignmentMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererGetAlignmentMethodInfo a signature where
    overloadedMethod = cellRendererGetAlignment

instance O.OverloadedMethodInfo CellRendererGetAlignmentMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetAlignment",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetAlignment"
        }


#endif

-- method CellRenderer::get_fixed_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "location to fill in with the fixed width of the cell, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "location to fill in with the fixed height of the cell, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_fixed_size" gtk_cell_renderer_get_fixed_size :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Int32 ->                            -- width : TBasicType TInt
    Ptr Int32 ->                            -- height : TBasicType TInt
    IO ()

-- | Fills in /@width@/ and /@height@/ with the appropriate size of /@cell@/.
cellRendererGetFixedSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m ((Int32, Int32))
cellRendererGetFixedSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> m (Int32, Int32)
cellRendererGetFixedSize a
cell = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Int32
width <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
height <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_cell_renderer_get_fixed_size Ptr CellRenderer
cell' Ptr Int32
width Ptr Int32
height
    Int32
width' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
width
    Int32
height' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
height
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
width
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
height
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
width', Int32
height')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetFixedSizeMethodInfo
instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererGetFixedSizeMethodInfo a signature where
    overloadedMethod = cellRendererGetFixedSize

instance O.OverloadedMethodInfo CellRendererGetFixedSizeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetFixedSize",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetFixedSize"
        }


#endif

-- method CellRenderer::get_is_expanded
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer" , 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_cell_renderer_get_is_expanded" gtk_cell_renderer_get_is_expanded :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    IO CInt

-- | Checks whether the given t'GI.Gtk.Objects.CellRenderer.CellRenderer' is expanded.
cellRendererGetIsExpanded ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the cell renderer is expanded
cellRendererGetIsExpanded :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> m Bool
cellRendererGetIsExpanded a
cell = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    CInt
result <- Ptr CellRenderer -> IO CInt
gtk_cell_renderer_get_is_expanded Ptr CellRenderer
cell'
    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
cell
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CellRendererGetIsExpandedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererGetIsExpandedMethodInfo a signature where
    overloadedMethod = cellRendererGetIsExpanded

instance O.OverloadedMethodInfo CellRendererGetIsExpandedMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetIsExpanded",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetIsExpanded"
        }


#endif

-- method CellRenderer::get_is_expander
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer" , 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_cell_renderer_get_is_expander" gtk_cell_renderer_get_is_expander :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    IO CInt

-- | Checks whether the given t'GI.Gtk.Objects.CellRenderer.CellRenderer' is an expander.
cellRendererGetIsExpander ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@cell@/ is an expander, and 'P.False' otherwise
cellRendererGetIsExpander :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> m Bool
cellRendererGetIsExpander a
cell = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    CInt
result <- Ptr CellRenderer -> IO CInt
gtk_cell_renderer_get_is_expander Ptr CellRenderer
cell'
    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
cell
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CellRendererGetIsExpanderMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererGetIsExpanderMethodInfo a signature where
    overloadedMethod = cellRendererGetIsExpander

instance O.OverloadedMethodInfo CellRendererGetIsExpanderMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetIsExpander",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetIsExpander"
        }


#endif

-- method CellRenderer::get_padding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xpad"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "location to fill in with the x padding of the cell, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "ypad"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "location to fill in with the y padding of the cell, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_padding" gtk_cell_renderer_get_padding :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Int32 ->                            -- xpad : TBasicType TInt
    Ptr Int32 ->                            -- ypad : TBasicType TInt
    IO ()

-- | Fills in /@xpad@/ and /@ypad@/ with the appropriate values of /@cell@/.
cellRendererGetPadding ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m ((Int32, Int32))
cellRendererGetPadding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> m (Int32, Int32)
cellRendererGetPadding a
cell = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Int32
xpad <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
ypad <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_cell_renderer_get_padding Ptr CellRenderer
cell' Ptr Int32
xpad Ptr Int32
ypad
    Int32
xpad' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
xpad
    Int32
ypad' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
ypad
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
xpad
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
ypad
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
xpad', Int32
ypad')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetPaddingMethodInfo
instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererGetPaddingMethodInfo a signature where
    overloadedMethod = cellRendererGetPadding

instance O.OverloadedMethodInfo CellRendererGetPaddingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetPadding",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetPadding"
        }


#endif

-- method CellRenderer::get_preferred_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GtkWidget this cell will be rendering to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "minimum_size"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to store the minimum size, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "natural_size"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to store the natural size, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_preferred_height" gtk_cell_renderer_get_preferred_height :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Int32 ->                            -- minimum_size : TBasicType TInt
    Ptr Int32 ->                            -- natural_size : TBasicType TInt
    IO ()

-- | Retrieves a renderer’s natural size when rendered to /@widget@/.
cellRendererGetPreferredHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer' instance
    -> b
    -- ^ /@widget@/: the t'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to
    -> m ((Int32, Int32))
cellRendererGetPreferredHeight :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) =>
a -> b -> m (Int32, Int32)
cellRendererGetPreferredHeight a
cell b
widget = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Int32
minimumSize <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
naturalSize <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer -> Ptr Widget -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_cell_renderer_get_preferred_height Ptr CellRenderer
cell' Ptr Widget
widget' Ptr Int32
minimumSize Ptr Int32
naturalSize
    Int32
minimumSize' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
minimumSize
    Int32
naturalSize' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
naturalSize
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
minimumSize
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
naturalSize
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
minimumSize', Int32
naturalSize')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetPreferredHeightMethodInfo
instance (signature ~ (b -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.OverloadedMethod CellRendererGetPreferredHeightMethodInfo a signature where
    overloadedMethod = cellRendererGetPreferredHeight

instance O.OverloadedMethodInfo CellRendererGetPreferredHeightMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredHeight",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetPreferredHeight"
        }


#endif

-- method CellRenderer::get_preferred_height_for_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GtkWidget this cell will be rendering to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the size which is available for allocation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "minimum_height"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "location for storing the minimum size, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "natural_height"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "location for storing the preferred size, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_preferred_height_for_width" gtk_cell_renderer_get_preferred_height_for_width :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- width : TBasicType TInt
    Ptr Int32 ->                            -- minimum_height : TBasicType TInt
    Ptr Int32 ->                            -- natural_height : TBasicType TInt
    IO ()

-- | Retrieves a cell renderers’s minimum and natural height if it were rendered to
-- /@widget@/ with the specified /@width@/.
cellRendererGetPreferredHeightForWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer' instance
    -> b
    -- ^ /@widget@/: the t'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to
    -> Int32
    -- ^ /@width@/: the size which is available for allocation
    -> m ((Int32, Int32))
cellRendererGetPreferredHeightForWidth :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) =>
a -> b -> Int32 -> m (Int32, Int32)
cellRendererGetPreferredHeightForWidth a
cell b
widget Int32
width = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Int32
minimumHeight <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
naturalHeight <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer
-> Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_cell_renderer_get_preferred_height_for_width Ptr CellRenderer
cell' Ptr Widget
widget' Int32
width Ptr Int32
minimumHeight Ptr Int32
naturalHeight
    Int32
minimumHeight' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
minimumHeight
    Int32
naturalHeight' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
naturalHeight
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
minimumHeight
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
naturalHeight
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
minimumHeight', Int32
naturalHeight')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetPreferredHeightForWidthMethodInfo
instance (signature ~ (b -> Int32 -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.OverloadedMethod CellRendererGetPreferredHeightForWidthMethodInfo a signature where
    overloadedMethod = cellRendererGetPreferredHeightForWidth

instance O.OverloadedMethodInfo CellRendererGetPreferredHeightForWidthMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredHeightForWidth",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetPreferredHeightForWidth"
        }


#endif

-- method CellRenderer::get_preferred_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GtkWidget this cell will be rendering to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "minimum_size"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Requisition" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "location for storing the minimum size, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "natural_size"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Requisition" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "location for storing the natural size, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_preferred_size" gtk_cell_renderer_get_preferred_size :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Requisition.Requisition ->      -- minimum_size : TInterface (Name {namespace = "Gtk", name = "Requisition"})
    Ptr Gtk.Requisition.Requisition ->      -- natural_size : TInterface (Name {namespace = "Gtk", name = "Requisition"})
    IO ()

-- | Retrieves the minimum and natural size of a cell taking
-- into account the widget’s preference for height-for-width management.
cellRendererGetPreferredSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer' instance
    -> b
    -- ^ /@widget@/: the t'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to
    -> m ((Gtk.Requisition.Requisition, Gtk.Requisition.Requisition))
cellRendererGetPreferredSize :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) =>
a -> b -> m (Requisition, Requisition)
cellRendererGetPreferredSize a
cell b
widget = IO (Requisition, Requisition) -> m (Requisition, Requisition)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Requisition, Requisition) -> m (Requisition, Requisition))
-> IO (Requisition, Requisition) -> m (Requisition, Requisition)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Requisition
minimumSize <- Int -> IO (Ptr Requisition)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
8 :: IO (Ptr Gtk.Requisition.Requisition)
    Ptr Requisition
naturalSize <- Int -> IO (Ptr Requisition)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
8 :: IO (Ptr Gtk.Requisition.Requisition)
    Ptr CellRenderer
-> Ptr Widget -> Ptr Requisition -> Ptr Requisition -> IO ()
gtk_cell_renderer_get_preferred_size Ptr CellRenderer
cell' Ptr Widget
widget' Ptr Requisition
minimumSize Ptr Requisition
naturalSize
    Requisition
minimumSize' <- ((ManagedPtr Requisition -> Requisition)
-> Ptr Requisition -> IO Requisition
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Requisition -> Requisition
Gtk.Requisition.Requisition) Ptr Requisition
minimumSize
    Requisition
naturalSize' <- ((ManagedPtr Requisition -> Requisition)
-> Ptr Requisition -> IO Requisition
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Requisition -> Requisition
Gtk.Requisition.Requisition) Ptr Requisition
naturalSize
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    (Requisition, Requisition) -> IO (Requisition, Requisition)
forall (m :: * -> *) a. Monad m => a -> m a
return (Requisition
minimumSize', Requisition
naturalSize')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetPreferredSizeMethodInfo
instance (signature ~ (b -> m ((Gtk.Requisition.Requisition, Gtk.Requisition.Requisition))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.OverloadedMethod CellRendererGetPreferredSizeMethodInfo a signature where
    overloadedMethod = cellRendererGetPreferredSize

instance O.OverloadedMethodInfo CellRendererGetPreferredSizeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredSize",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetPreferredSize"
        }


#endif

-- method CellRenderer::get_preferred_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GtkWidget this cell will be rendering to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "minimum_size"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to store the minimum size, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "natural_size"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to store the natural size, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_preferred_width" gtk_cell_renderer_get_preferred_width :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Int32 ->                            -- minimum_size : TBasicType TInt
    Ptr Int32 ->                            -- natural_size : TBasicType TInt
    IO ()

-- | Retrieves a renderer’s natural size when rendered to /@widget@/.
cellRendererGetPreferredWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer' instance
    -> b
    -- ^ /@widget@/: the t'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to
    -> m ((Int32, Int32))
cellRendererGetPreferredWidth :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) =>
a -> b -> m (Int32, Int32)
cellRendererGetPreferredWidth a
cell b
widget = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Int32
minimumSize <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
naturalSize <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer -> Ptr Widget -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_cell_renderer_get_preferred_width Ptr CellRenderer
cell' Ptr Widget
widget' Ptr Int32
minimumSize Ptr Int32
naturalSize
    Int32
minimumSize' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
minimumSize
    Int32
naturalSize' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
naturalSize
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
minimumSize
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
naturalSize
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
minimumSize', Int32
naturalSize')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetPreferredWidthMethodInfo
instance (signature ~ (b -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.OverloadedMethod CellRendererGetPreferredWidthMethodInfo a signature where
    overloadedMethod = cellRendererGetPreferredWidth

instance O.OverloadedMethodInfo CellRendererGetPreferredWidthMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredWidth",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetPreferredWidth"
        }


#endif

-- method CellRenderer::get_preferred_width_for_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GtkWidget this cell will be rendering to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the size which is available for allocation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "minimum_width"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "location for storing the minimum size, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "natural_width"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "location for storing the preferred size, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_preferred_width_for_height" gtk_cell_renderer_get_preferred_width_for_height :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- height : TBasicType TInt
    Ptr Int32 ->                            -- minimum_width : TBasicType TInt
    Ptr Int32 ->                            -- natural_width : TBasicType TInt
    IO ()

-- | Retrieves a cell renderers’s minimum and natural width if it were rendered to
-- /@widget@/ with the specified /@height@/.
cellRendererGetPreferredWidthForHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer' instance
    -> b
    -- ^ /@widget@/: the t'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to
    -> Int32
    -- ^ /@height@/: the size which is available for allocation
    -> m ((Int32, Int32))
cellRendererGetPreferredWidthForHeight :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) =>
a -> b -> Int32 -> m (Int32, Int32)
cellRendererGetPreferredWidthForHeight a
cell b
widget Int32
height = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Int32
minimumWidth <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
naturalWidth <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer
-> Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_cell_renderer_get_preferred_width_for_height Ptr CellRenderer
cell' Ptr Widget
widget' Int32
height Ptr Int32
minimumWidth Ptr Int32
naturalWidth
    Int32
minimumWidth' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
minimumWidth
    Int32
naturalWidth' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
naturalWidth
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
minimumWidth
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
naturalWidth
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
minimumWidth', Int32
naturalWidth')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetPreferredWidthForHeightMethodInfo
instance (signature ~ (b -> Int32 -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.OverloadedMethod CellRendererGetPreferredWidthForHeightMethodInfo a signature where
    overloadedMethod = cellRendererGetPreferredWidthForHeight

instance O.OverloadedMethodInfo CellRendererGetPreferredWidthForHeightMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredWidthForHeight",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetPreferredWidthForHeight"
        }


#endif

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

foreign import ccall "gtk_cell_renderer_get_request_mode" gtk_cell_renderer_get_request_mode :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    IO CUInt

-- | Gets whether the cell renderer prefers a height-for-width layout
-- or a width-for-height layout.
cellRendererGetRequestMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'    instance
    -> m Gtk.Enums.SizeRequestMode
    -- ^ __Returns:__ The t'GI.Gtk.Enums.SizeRequestMode' preferred by this renderer.
cellRendererGetRequestMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> m SizeRequestMode
cellRendererGetRequestMode a
cell = IO SizeRequestMode -> m SizeRequestMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SizeRequestMode -> m SizeRequestMode)
-> IO SizeRequestMode -> m SizeRequestMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    CUInt
result <- Ptr CellRenderer -> IO CUInt
gtk_cell_renderer_get_request_mode Ptr CellRenderer
cell'
    let result' :: SizeRequestMode
result' = (Int -> SizeRequestMode
forall a. Enum a => Int -> a
toEnum (Int -> SizeRequestMode)
-> (CUInt -> Int) -> CUInt -> SizeRequestMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    SizeRequestMode -> IO SizeRequestMode
forall (m :: * -> *) a. Monad m => a -> m a
return SizeRequestMode
result'

#if defined(ENABLE_OVERLOADING)
data CellRendererGetRequestModeMethodInfo
instance (signature ~ (m Gtk.Enums.SizeRequestMode), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererGetRequestModeMethodInfo a signature where
    overloadedMethod = cellRendererGetRequestMode

instance O.OverloadedMethodInfo CellRendererGetRequestModeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetRequestMode",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetRequestMode"
        }


#endif

-- method CellRenderer::get_sensitive
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkCellRenderer" , 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_cell_renderer_get_sensitive" gtk_cell_renderer_get_sensitive :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    IO CInt

-- | Returns the cell renderer’s sensitivity.
cellRendererGetSensitive ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the cell renderer is sensitive
cellRendererGetSensitive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> m Bool
cellRendererGetSensitive a
cell = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    CInt
result <- Ptr CellRenderer -> IO CInt
gtk_cell_renderer_get_sensitive Ptr CellRenderer
cell'
    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
cell
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CellRendererGetSensitiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererGetSensitiveMethodInfo a signature where
    overloadedMethod = cellRendererGetSensitive

instance O.OverloadedMethodInfo CellRendererGetSensitiveMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetSensitive",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetSensitive"
        }


#endif

-- method CellRenderer::get_state
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidget, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cell_state"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRendererState" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "cell renderer state"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "StateFlags" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_state" gtk_cell_renderer_get_state :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- cell_state : TInterface (Name {namespace = "Gtk", name = "CellRendererState"})
    IO CUInt

-- | Translates the cell renderer state to t'GI.Gtk.Flags.StateFlags',
-- based on the cell renderer and widget sensitivity, and
-- the given t'GI.Gtk.Flags.CellRendererState'.
cellRendererGetState ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer', or 'P.Nothing'
    -> Maybe (b)
    -- ^ /@widget@/: a t'GI.Gtk.Objects.Widget.Widget', or 'P.Nothing'
    -> [Gtk.Flags.CellRendererState]
    -- ^ /@cellState@/: cell renderer state
    -> m [Gtk.Flags.StateFlags]
    -- ^ __Returns:__ the widget state flags applying to /@cell@/
cellRendererGetState :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) =>
a -> Maybe b -> [CellRendererState] -> m [StateFlags]
cellRendererGetState a
cell Maybe b
widget [CellRendererState]
cellState = IO [StateFlags] -> m [StateFlags]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [StateFlags] -> m [StateFlags])
-> IO [StateFlags] -> m [StateFlags]
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
maybeWidget <- case Maybe b
widget 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
jWidget -> do
            Ptr Widget
jWidget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jWidget
            Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jWidget'
    let cellState' :: CUInt
cellState' = [CellRendererState] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [CellRendererState]
cellState
    CUInt
result <- Ptr CellRenderer -> Ptr Widget -> CUInt -> IO CUInt
gtk_cell_renderer_get_state Ptr CellRenderer
cell' Ptr Widget
maybeWidget CUInt
cellState'
    let result' :: [StateFlags]
result' = CUInt -> [StateFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
widget b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    [StateFlags] -> IO [StateFlags]
forall (m :: * -> *) a. Monad m => a -> m a
return [StateFlags]
result'

#if defined(ENABLE_OVERLOADING)
data CellRendererGetStateMethodInfo
instance (signature ~ (Maybe (b) -> [Gtk.Flags.CellRendererState] -> m [Gtk.Flags.StateFlags]), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.OverloadedMethod CellRendererGetStateMethodInfo a signature where
    overloadedMethod = cellRendererGetState

instance O.OverloadedMethodInfo CellRendererGetStateMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetState",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetState"
        }


#endif

-- method CellRenderer::get_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkCellRenderer" , 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_cell_renderer_get_visible" gtk_cell_renderer_get_visible :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    IO CInt

-- | Returns the cell renderer’s visibility.
cellRendererGetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the cell renderer is visible
cellRendererGetVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> m Bool
cellRendererGetVisible a
cell = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    CInt
result <- Ptr CellRenderer -> IO CInt
gtk_cell_renderer_get_visible Ptr CellRenderer
cell'
    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
cell
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CellRendererGetVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererGetVisibleMethodInfo a signature where
    overloadedMethod = cellRendererGetVisible

instance O.OverloadedMethodInfo CellRendererGetVisibleMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererGetVisible",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetVisible"
        }


#endif

-- method CellRenderer::is_activatable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkCellRenderer" , 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_cell_renderer_is_activatable" gtk_cell_renderer_is_activatable :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    IO CInt

-- | Checks whether the cell renderer can do something when activated.
cellRendererIsActivatable ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the cell renderer can do anything when activated
cellRendererIsActivatable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> m Bool
cellRendererIsActivatable a
cell = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    CInt
result <- Ptr CellRenderer -> IO CInt
gtk_cell_renderer_is_activatable Ptr CellRenderer
cell'
    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
cell
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CellRendererIsActivatableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererIsActivatableMethodInfo a signature where
    overloadedMethod = cellRendererIsActivatable

instance O.OverloadedMethodInfo CellRendererIsActivatableMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererIsActivatable",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererIsActivatable"
        }


#endif

-- method CellRenderer::set_alignment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xalign"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the x alignment of the cell renderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "yalign"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the y alignment of the cell renderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_set_alignment" gtk_cell_renderer_set_alignment :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    CFloat ->                               -- xalign : TBasicType TFloat
    CFloat ->                               -- yalign : TBasicType TFloat
    IO ()

-- | Sets the renderer’s alignment within its available space.
cellRendererSetAlignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Float
    -- ^ /@xalign@/: the x alignment of the cell renderer
    -> Float
    -- ^ /@yalign@/: the y alignment of the cell renderer
    -> m ()
cellRendererSetAlignment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> Float -> Float -> m ()
cellRendererSetAlignment a
cell Float
xalign Float
yalign = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    let xalign' :: CFloat
xalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
xalign
    let yalign' :: CFloat
yalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
yalign
    Ptr CellRenderer -> CFloat -> CFloat -> IO ()
gtk_cell_renderer_set_alignment Ptr CellRenderer
cell' CFloat
xalign' CFloat
yalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererSetAlignmentMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererSetAlignmentMethodInfo a signature where
    overloadedMethod = cellRendererSetAlignment

instance O.OverloadedMethodInfo CellRendererSetAlignmentMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererSetAlignment",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererSetAlignment"
        }


#endif

-- method CellRenderer::set_fixed_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the width of the cell renderer, or -1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the height of the cell renderer, or -1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_set_fixed_size" gtk_cell_renderer_set_fixed_size :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Int32 ->                                -- width : TBasicType TInt
    Int32 ->                                -- height : TBasicType TInt
    IO ()

-- | Sets the renderer size to be explicit, independent of the properties set.
cellRendererSetFixedSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Int32
    -- ^ /@width@/: the width of the cell renderer, or -1
    -> Int32
    -- ^ /@height@/: the height of the cell renderer, or -1
    -> m ()
cellRendererSetFixedSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> Int32 -> Int32 -> m ()
cellRendererSetFixedSize a
cell Int32
width Int32
height = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr CellRenderer -> Int32 -> Int32 -> IO ()
gtk_cell_renderer_set_fixed_size Ptr CellRenderer
cell' Int32
width Int32
height
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererSetFixedSizeMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererSetFixedSizeMethodInfo a signature where
    overloadedMethod = cellRendererSetFixedSize

instance O.OverloadedMethodInfo CellRendererSetFixedSizeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererSetFixedSize",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererSetFixedSize"
        }


#endif

-- method CellRenderer::set_is_expanded
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_expanded"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether @cell should be expanded"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_set_is_expanded" gtk_cell_renderer_set_is_expanded :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    CInt ->                                 -- is_expanded : TBasicType TBoolean
    IO ()

-- | Sets whether the given t'GI.Gtk.Objects.CellRenderer.CellRenderer' is expanded.
cellRendererSetIsExpanded ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Bool
    -- ^ /@isExpanded@/: whether /@cell@/ should be expanded
    -> m ()
cellRendererSetIsExpanded :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> Bool -> m ()
cellRendererSetIsExpanded a
cell Bool
isExpanded = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    let isExpanded' :: CInt
isExpanded' = (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
isExpanded
    Ptr CellRenderer -> CInt -> IO ()
gtk_cell_renderer_set_is_expanded Ptr CellRenderer
cell' CInt
isExpanded'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererSetIsExpandedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererSetIsExpandedMethodInfo a signature where
    overloadedMethod = cellRendererSetIsExpanded

instance O.OverloadedMethodInfo CellRendererSetIsExpandedMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererSetIsExpanded",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererSetIsExpanded"
        }


#endif

-- method CellRenderer::set_is_expander
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_expander"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether @cell is an expander"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_set_is_expander" gtk_cell_renderer_set_is_expander :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    CInt ->                                 -- is_expander : TBasicType TBoolean
    IO ()

-- | Sets whether the given t'GI.Gtk.Objects.CellRenderer.CellRenderer' is an expander.
cellRendererSetIsExpander ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Bool
    -- ^ /@isExpander@/: whether /@cell@/ is an expander
    -> m ()
cellRendererSetIsExpander :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> Bool -> m ()
cellRendererSetIsExpander a
cell Bool
isExpander = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    let isExpander' :: CInt
isExpander' = (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
isExpander
    Ptr CellRenderer -> CInt -> IO ()
gtk_cell_renderer_set_is_expander Ptr CellRenderer
cell' CInt
isExpander'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererSetIsExpanderMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererSetIsExpanderMethodInfo a signature where
    overloadedMethod = cellRendererSetIsExpander

instance O.OverloadedMethodInfo CellRendererSetIsExpanderMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererSetIsExpander",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererSetIsExpander"
        }


#endif

-- method CellRenderer::set_padding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xpad"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the x padding of the cell renderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ypad"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the y padding of the cell renderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_set_padding" gtk_cell_renderer_set_padding :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Int32 ->                                -- xpad : TBasicType TInt
    Int32 ->                                -- ypad : TBasicType TInt
    IO ()

-- | Sets the renderer’s padding.
cellRendererSetPadding ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Int32
    -- ^ /@xpad@/: the x padding of the cell renderer
    -> Int32
    -- ^ /@ypad@/: the y padding of the cell renderer
    -> m ()
cellRendererSetPadding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> Int32 -> Int32 -> m ()
cellRendererSetPadding a
cell Int32
xpad Int32
ypad = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr CellRenderer -> Int32 -> Int32 -> IO ()
gtk_cell_renderer_set_padding Ptr CellRenderer
cell' Int32
xpad Int32
ypad
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererSetPaddingMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererSetPaddingMethodInfo a signature where
    overloadedMethod = cellRendererSetPadding

instance O.OverloadedMethodInfo CellRendererSetPaddingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererSetPadding",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererSetPadding"
        }


#endif

-- method CellRenderer::set_sensitive
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sensitive"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the sensitivity of the cell"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_set_sensitive" gtk_cell_renderer_set_sensitive :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    CInt ->                                 -- sensitive : TBasicType TBoolean
    IO ()

-- | Sets the cell renderer’s sensitivity.
cellRendererSetSensitive ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Bool
    -- ^ /@sensitive@/: the sensitivity of the cell
    -> m ()
cellRendererSetSensitive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> Bool -> m ()
cellRendererSetSensitive a
cell Bool
sensitive = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    let sensitive' :: CInt
sensitive' = (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
sensitive
    Ptr CellRenderer -> CInt -> IO ()
gtk_cell_renderer_set_sensitive Ptr CellRenderer
cell' CInt
sensitive'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererSetSensitiveMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererSetSensitiveMethodInfo a signature where
    overloadedMethod = cellRendererSetSensitive

instance O.OverloadedMethodInfo CellRendererSetSensitiveMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererSetSensitive",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererSetSensitive"
        }


#endif

-- method CellRenderer::set_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the visibility of the cell"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_set_visible" gtk_cell_renderer_set_visible :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

-- | Sets the cell renderer’s visibility.
cellRendererSetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Bool
    -- ^ /@visible@/: the visibility of the cell
    -> m ()
cellRendererSetVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> Bool -> m ()
cellRendererSetVisible a
cell Bool
visible = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    let visible' :: CInt
visible' = (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
visible
    Ptr CellRenderer -> CInt -> IO ()
gtk_cell_renderer_set_visible Ptr CellRenderer
cell' CInt
visible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererSetVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererSetVisibleMethodInfo a signature where
    overloadedMethod = cellRendererSetVisible

instance O.OverloadedMethodInfo CellRendererSetVisibleMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererSetVisible",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererSetVisible"
        }


#endif

-- method CellRenderer::snapshot
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "snapshot"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Snapshot" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSnapshot to draw to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the widget owning @window"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "background_area"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "entire cell area (including tree expanders and maybe\n   padding on the sides)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cell_area"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "area normally rendered by a cell renderer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRendererState" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags that affect rendering"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_snapshot" gtk_cell_renderer_snapshot :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Gtk.Snapshot.Snapshot ->            -- snapshot : TInterface (Name {namespace = "Gtk", name = "Snapshot"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Rectangle.Rectangle ->          -- background_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Ptr Gdk.Rectangle.Rectangle ->          -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gtk", name = "CellRendererState"})
    IO ()

-- | Invokes the virtual render function of the t'GI.Gtk.Objects.CellRenderer.CellRenderer'. The three
-- passed-in rectangles are areas in /@cr@/. Most renderers will draw within
-- /@cellArea@/; the xalign, yalign, xpad, and ypad fields of the t'GI.Gtk.Objects.CellRenderer.CellRenderer'
-- should be honored with respect to /@cellArea@/. /@backgroundArea@/ includes the
-- blank space around the cell, and also the area containing the tree expander;
-- so the /@backgroundArea@/ rectangles for all cells tile to cover the entire
-- /@window@/.
cellRendererSnapshot ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Snapshot.IsSnapshot b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> b
    -- ^ /@snapshot@/: a @/GtkSnapshot/@ to draw to
    -> c
    -- ^ /@widget@/: the widget owning /@window@/
    -> Gdk.Rectangle.Rectangle
    -- ^ /@backgroundArea@/: entire cell area (including tree expanders and maybe
    --    padding on the sides)
    -> Gdk.Rectangle.Rectangle
    -- ^ /@cellArea@/: area normally rendered by a cell renderer
    -> [Gtk.Flags.CellRendererState]
    -- ^ /@flags@/: flags that affect rendering
    -> m ()
cellRendererSnapshot :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsCellRenderer a, IsSnapshot b,
 IsWidget c) =>
a
-> b -> c -> Rectangle -> Rectangle -> [CellRendererState] -> m ()
cellRendererSnapshot a
cell b
snapshot c
widget Rectangle
backgroundArea Rectangle
cellArea [CellRendererState]
flags = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Snapshot
snapshot' <- b -> IO (Ptr Snapshot)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
snapshot
    Ptr Widget
widget' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
widget
    Ptr Rectangle
backgroundArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
backgroundArea
    Ptr Rectangle
cellArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
cellArea
    let flags' :: CUInt
flags' = [CellRendererState] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [CellRendererState]
flags
    Ptr CellRenderer
-> Ptr Snapshot
-> Ptr Widget
-> Ptr Rectangle
-> Ptr Rectangle
-> CUInt
-> IO ()
gtk_cell_renderer_snapshot Ptr CellRenderer
cell' Ptr Snapshot
snapshot' Ptr Widget
widget' Ptr Rectangle
backgroundArea' Ptr Rectangle
cellArea' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
snapshot
    c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
widget
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
backgroundArea
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
cellArea
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererSnapshotMethodInfo
instance (signature ~ (b -> c -> Gdk.Rectangle.Rectangle -> Gdk.Rectangle.Rectangle -> [Gtk.Flags.CellRendererState] -> m ()), MonadIO m, IsCellRenderer a, Gtk.Snapshot.IsSnapshot b, Gtk.Widget.IsWidget c) => O.OverloadedMethod CellRendererSnapshotMethodInfo a signature where
    overloadedMethod = cellRendererSnapshot

instance O.OverloadedMethodInfo CellRendererSnapshotMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererSnapshot",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererSnapshot"
        }


#endif

-- method CellRenderer::start_editing
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "event"
--           , argType = TInterface Name { namespace = "Gdk" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "widget that received the event"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "widget-dependent string representation of the event location;\n   e.g. for #GtkTreeView, a string representation of #GtkTreePath"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "background_area"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "background area as passed to gtk_cell_renderer_render()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cell_area"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "cell area as passed to gtk_cell_renderer_render()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRendererState" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "render flags" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "CellEditable" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_start_editing" gtk_cell_renderer_start_editing :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- path : TBasicType TUTF8
    Ptr Gdk.Rectangle.Rectangle ->          -- background_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Ptr Gdk.Rectangle.Rectangle ->          -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gtk", name = "CellRendererState"})
    IO (Ptr Gtk.CellEditable.CellEditable)

-- | Starts editing the contents of this /@cell@/, through a new t'GI.Gtk.Interfaces.CellEditable.CellEditable'
-- widget created by the t'GI.Gtk.Structs.CellRendererClass.CellRendererClass'.@/start_editing/@ virtual function.
cellRendererStartEditing ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gdk.Event.IsEvent b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Maybe (b)
    -- ^ /@event@/: a t'GI.Gdk.Objects.Event.Event'
    -> c
    -- ^ /@widget@/: widget that received the event
    -> T.Text
    -- ^ /@path@/: widget-dependent string representation of the event location;
    --    e.g. for t'GI.Gtk.Objects.TreeView.TreeView', a string representation of t'GI.Gtk.Structs.TreePath.TreePath'
    -> Gdk.Rectangle.Rectangle
    -- ^ /@backgroundArea@/: background area as passed to @/gtk_cell_renderer_render()/@
    -> Gdk.Rectangle.Rectangle
    -- ^ /@cellArea@/: cell area as passed to @/gtk_cell_renderer_render()/@
    -> [Gtk.Flags.CellRendererState]
    -- ^ /@flags@/: render flags
    -> m (Maybe Gtk.CellEditable.CellEditable)
    -- ^ __Returns:__ A new t'GI.Gtk.Interfaces.CellEditable.CellEditable' for editing this
    --   /@cell@/, or 'P.Nothing' if editing is not possible
cellRendererStartEditing :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsCellRenderer a, IsEvent b,
 IsWidget c) =>
a
-> Maybe b
-> c
-> Text
-> Rectangle
-> Rectangle
-> [CellRendererState]
-> m (Maybe CellEditable)
cellRendererStartEditing a
cell Maybe b
event c
widget Text
path Rectangle
backgroundArea Rectangle
cellArea [CellRendererState]
flags = IO (Maybe CellEditable) -> m (Maybe CellEditable)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe CellEditable) -> m (Maybe CellEditable))
-> IO (Maybe CellEditable) -> m (Maybe CellEditable)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Event
maybeEvent <- case Maybe b
event of
        Maybe b
Nothing -> Ptr Event -> IO (Ptr Event)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Event
forall a. Ptr a
nullPtr
        Just b
jEvent -> do
            Ptr Event
jEvent' <- b -> IO (Ptr Event)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jEvent
            Ptr Event -> IO (Ptr Event)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Event
jEvent'
    Ptr Widget
widget' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
widget
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr Rectangle
backgroundArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
backgroundArea
    Ptr Rectangle
cellArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
cellArea
    let flags' :: CUInt
flags' = [CellRendererState] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [CellRendererState]
flags
    Ptr CellEditable
result <- Ptr CellRenderer
-> Ptr Event
-> Ptr Widget
-> CString
-> Ptr Rectangle
-> Ptr Rectangle
-> CUInt
-> IO (Ptr CellEditable)
gtk_cell_renderer_start_editing Ptr CellRenderer
cell' Ptr Event
maybeEvent Ptr Widget
widget' CString
path' Ptr Rectangle
backgroundArea' Ptr Rectangle
cellArea' CUInt
flags'
    Maybe CellEditable
maybeResult <- Ptr CellEditable
-> (Ptr CellEditable -> IO CellEditable) -> IO (Maybe CellEditable)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CellEditable
result ((Ptr CellEditable -> IO CellEditable) -> IO (Maybe CellEditable))
-> (Ptr CellEditable -> IO CellEditable) -> IO (Maybe CellEditable)
forall a b. (a -> b) -> a -> b
$ \Ptr CellEditable
result' -> do
        CellEditable
result'' <- ((ManagedPtr CellEditable -> CellEditable)
-> Ptr CellEditable -> IO CellEditable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CellEditable -> CellEditable
Gtk.CellEditable.CellEditable) Ptr CellEditable
result'
        CellEditable -> IO CellEditable
forall (m :: * -> *) a. Monad m => a -> m a
return CellEditable
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
event b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
widget
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
backgroundArea
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
cellArea
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
    Maybe CellEditable -> IO (Maybe CellEditable)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CellEditable
maybeResult

#if defined(ENABLE_OVERLOADING)
data CellRendererStartEditingMethodInfo
instance (signature ~ (Maybe (b) -> c -> T.Text -> Gdk.Rectangle.Rectangle -> Gdk.Rectangle.Rectangle -> [Gtk.Flags.CellRendererState] -> m (Maybe Gtk.CellEditable.CellEditable)), MonadIO m, IsCellRenderer a, Gdk.Event.IsEvent b, Gtk.Widget.IsWidget c) => O.OverloadedMethod CellRendererStartEditingMethodInfo a signature where
    overloadedMethod = cellRendererStartEditing

instance O.OverloadedMethodInfo CellRendererStartEditingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererStartEditing",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererStartEditing"
        }


#endif

-- method CellRenderer::stop_editing
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cell"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "canceled"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the editing has been canceled"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_stop_editing" gtk_cell_renderer_stop_editing :: 
    Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
    CInt ->                                 -- canceled : TBasicType TBoolean
    IO ()

-- | Informs the cell renderer that the editing is stopped.
-- If /@canceled@/ is 'P.True', the cell renderer will emit the
-- [editingCanceled]("GI.Gtk.Objects.CellRenderer#g:signal:editingCanceled") signal.
-- 
-- This function should be called by cell renderer implementations
-- in response to the [editingDone]("GI.Gtk.Interfaces.CellEditable#g:signal:editingDone") signal of
-- t'GI.Gtk.Interfaces.CellEditable.CellEditable'.
cellRendererStopEditing ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Bool
    -- ^ /@canceled@/: 'P.True' if the editing has been canceled
    -> m ()
cellRendererStopEditing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCellRenderer a) =>
a -> Bool -> m ()
cellRendererStopEditing a
cell Bool
canceled = 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 CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    let canceled' :: CInt
canceled' = (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
canceled
    Ptr CellRenderer -> CInt -> IO ()
gtk_cell_renderer_stop_editing Ptr CellRenderer
cell' CInt
canceled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererStopEditingMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsCellRenderer a) => O.OverloadedMethod CellRendererStopEditingMethodInfo a signature where
    overloadedMethod = cellRendererStopEditing

instance O.OverloadedMethodInfo CellRendererStopEditingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.CellRenderer.cellRendererStopEditing",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererStopEditing"
        }


#endif