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

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- 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.cellRendererGetSize'. Finally, the cell
    -- is rendered in the correct location using 'GI.Gtk.Objects.CellRenderer.cellRendererRender'.
    --
    -- 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 t'GI.Gtk.Objects.Style.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 !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"), [render]("GI.Gtk.Objects.CellRenderer#g:method:render"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [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"), [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"), [getSize]("GI.Gtk.Objects.CellRenderer#g:method:getSize"), [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"), [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                ,

    -- ** 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                ,

    -- ** getSize #method:getSize#

    #if defined(ENABLE_OVERLOADING)
        CellRendererGetSizeMethodInfo           ,
    #endif
        cellRendererGetSize                     ,

    -- ** 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               ,

    -- ** render #method:render#

    #if defined(ENABLE_OVERLOADING)
        CellRendererRenderMethodInfo            ,
    #endif
        cellRendererRender                      ,

    -- ** setAlignment #method:setAlignment#

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

    -- ** setFixedSize #method:setFixedSize#

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

    -- ** 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                  ,

    -- ** 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           ,

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

    #if defined(ENABLE_OVERLOADING)
        CellRendererCellBackgroundGdkPropertyInfo,
    #endif
    #if defined(ENABLE_OVERLOADING)
        cellRendererCellBackgroundGdk           ,
    #endif
        clearCellRendererCellBackgroundGdk      ,
        constructCellRendererCellBackgroundGdk  ,
        getCellRendererCellBackgroundGdk        ,
        setCellRendererCellBackgroundGdk        ,

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

    #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#

        CellRendererEditingCanceledCallback     ,
    #if defined(ENABLE_OVERLOADING)
        CellRendererEditingCanceledSignalInfo   ,
    #endif
        afterCellRendererEditingCanceled        ,
        onCellRendererEditingCanceled           ,

    -- ** editingStarted #signal:editingStarted#

        CellRendererEditingStartedCallback      ,
    #if defined(ENABLE_OVERLOADING)
        CellRendererEditingStartedSignalInfo    ,
    #endif
        afterCellRendererEditingStarted         ,
        onCellRendererEditingStarted            ,

        ) where

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

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

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
    import qualified GI.Atk.Objects.Object as Atk.Object
    import qualified GI.Cairo.Structs.Context as Cairo.Context
    import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
    import qualified GI.Cairo.Structs.Region as Cairo.Region
    import qualified GI.Cairo.Structs.Surface as Cairo.Surface
    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.GLib.Structs.MarkupParser as GLib.MarkupParser
    import qualified GI.GObject.Callbacks as GObject.Callbacks
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Enums as Gdk.Enums
    import qualified GI.Gdk.Flags as Gdk.Flags
    import qualified GI.Gdk.Objects.Device as Gdk.Device
    import qualified GI.Gdk.Objects.Display as Gdk.Display
    import qualified GI.Gdk.Objects.DragContext as Gdk.DragContext
    import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
    import qualified GI.Gdk.Objects.Screen as Gdk.Screen
    import qualified GI.Gdk.Objects.Visual as Gdk.Visual
    import qualified GI.Gdk.Objects.Window as Gdk.Window
    import qualified GI.Gdk.Structs.Atom as Gdk.Atom
    import qualified GI.Gdk.Structs.Color as Gdk.Color
    import qualified GI.Gdk.Structs.EventAny as Gdk.EventAny
    import qualified GI.Gdk.Structs.EventButton as Gdk.EventButton
    import qualified GI.Gdk.Structs.EventConfigure as Gdk.EventConfigure
    import qualified GI.Gdk.Structs.EventCrossing as Gdk.EventCrossing
    import qualified GI.Gdk.Structs.EventExpose as Gdk.EventExpose
    import qualified GI.Gdk.Structs.EventFocus as Gdk.EventFocus
    import qualified GI.Gdk.Structs.EventGrabBroken as Gdk.EventGrabBroken
    import qualified GI.Gdk.Structs.EventKey as Gdk.EventKey
    import qualified GI.Gdk.Structs.EventMotion as Gdk.EventMotion
    import qualified GI.Gdk.Structs.EventOwnerChange as Gdk.EventOwnerChange
    import qualified GI.Gdk.Structs.EventProperty as Gdk.EventProperty
    import qualified GI.Gdk.Structs.EventProximity as Gdk.EventProximity
    import qualified GI.Gdk.Structs.EventScroll as Gdk.EventScroll
    import qualified GI.Gdk.Structs.EventSelection as Gdk.EventSelection
    import qualified GI.Gdk.Structs.EventVisibility as Gdk.EventVisibility
    import qualified GI.Gdk.Structs.EventWindowState as Gdk.EventWindowState
    import qualified GI.Gdk.Structs.Geometry as Gdk.Geometry
    import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
    import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
    import qualified GI.Gdk.Unions.Event as Gdk.Event
    import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
    import qualified GI.Gio.Flags as Gio.Flags
    import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
    import qualified GI.Gio.Interfaces.ActionMap as Gio.ActionMap
    import qualified GI.Gio.Interfaces.File as Gio.File
    import qualified GI.Gio.Interfaces.Icon as Gio.Icon
    import qualified GI.Gio.Objects.Application as Gio.Application
    import qualified GI.Gio.Objects.Menu as Gio.Menu
    import qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
    import qualified GI.Gtk.Callbacks as Gtk.Callbacks
    import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
    import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.CellEditable as Gtk.CellEditable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
    import {-# SOURCE #-} qualified GI.Gtk.Objects.AccelGroup as Gtk.AccelGroup
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Adjustment as Gtk.Adjustment
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Application as Gtk.Application
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Bin as Gtk.Bin
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Builder as Gtk.Builder
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Clipboard as Gtk.Clipboard
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Container as Gtk.Container
    import {-# SOURCE #-} qualified GI.Gtk.Objects.IconFactory as Gtk.IconFactory
    import {-# SOURCE #-} qualified GI.Gtk.Objects.RcStyle as Gtk.RcStyle
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Style as Gtk.Style
    import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleProperties as Gtk.StyleProperties
    import {-# SOURCE #-} qualified GI.Gtk.Objects.TextBuffer as Gtk.TextBuffer
    import {-# SOURCE #-} qualified GI.Gtk.Objects.TextChildAnchor as Gtk.TextChildAnchor
    import {-# SOURCE #-} qualified GI.Gtk.Objects.TextMark as Gtk.TextMark
    import {-# SOURCE #-} qualified GI.Gtk.Objects.TextTag as Gtk.TextTag
    import {-# SOURCE #-} qualified GI.Gtk.Objects.TextTagTable as Gtk.TextTagTable
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Window as Gtk.Window
    import {-# SOURCE #-} qualified GI.Gtk.Objects.WindowGroup as Gtk.WindowGroup
    import {-# SOURCE #-} qualified GI.Gtk.Structs.AccelGroupEntry as Gtk.AccelGroupEntry
    import {-# SOURCE #-} qualified GI.Gtk.Structs.AccelKey as Gtk.AccelKey
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Border as Gtk.Border
    import {-# SOURCE #-} qualified GI.Gtk.Structs.CssSection as Gtk.CssSection
    import {-# SOURCE #-} qualified GI.Gtk.Structs.IconSet as Gtk.IconSet
    import {-# SOURCE #-} qualified GI.Gtk.Structs.IconSource as Gtk.IconSource
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
    import {-# SOURCE #-} qualified GI.Gtk.Structs.SelectionData as Gtk.SelectionData
    import {-# SOURCE #-} qualified GI.Gtk.Structs.SettingsValue as Gtk.SettingsValue
    import {-# SOURCE #-} qualified GI.Gtk.Structs.SymbolicColor as Gtk.SymbolicColor
    import {-# SOURCE #-} qualified GI.Gtk.Structs.TargetEntry as Gtk.TargetEntry
    import {-# SOURCE #-} qualified GI.Gtk.Structs.TargetList as Gtk.TargetList
    import {-# SOURCE #-} qualified GI.Gtk.Structs.TextAppearance as Gtk.TextAppearance
    import {-# SOURCE #-} qualified GI.Gtk.Structs.TextAttributes as Gtk.TextAttributes
    import {-# SOURCE #-} qualified GI.Gtk.Structs.TextIter as Gtk.TextIter
    import {-# SOURCE #-} qualified GI.Gtk.Structs.WidgetPath as Gtk.WidgetPath
    import qualified GI.Pango.Enums as Pango.Enums
    import qualified GI.Pango.Objects.Context as Pango.Context
    import qualified GI.Pango.Objects.FontMap as Pango.FontMap
    import qualified GI.Pango.Objects.Layout as Pango.Layout
    import qualified GI.Pango.Structs.FontDescription as Pango.FontDescription
    import qualified GI.Pango.Structs.Language as Pango.Language
    import qualified GI.Pango.Structs.TabArray as Pango.TabArray

    #else
    import qualified GI.Cairo.Structs.Context as Cairo.Context
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Structs.Color as Gdk.Color
    import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
    import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
    import qualified GI.Gdk.Unions.Event as Gdk.Event
    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.Widget as Gtk.Widget
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition

    #endif

    -- | 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
    $c== :: CellRenderer -> CellRenderer -> Bool
    == :: CellRenderer -> CellRenderer -> Bool
    $c/= :: CellRenderer -> CellRenderer -> Bool
    /= :: 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 t'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 t'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 a. IO a -> m a
    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 t'CellRenderer' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue (Maybe 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 <- 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 /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newObject CellRenderer ptr
            else return P.Nothing

    #if defined(ENABLE_OVERLOADING)
    type family ResolveCellRendererMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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 "render" o = CellRendererRenderMethodInfo
        ResolveCellRendererMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        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 "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 "getSize" o = CellRendererGetSizeMethodInfo
        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 "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'.
    --
    -- /Since: 2.4/
    type CellRendererEditingCanceledCallback =
        IO ()

    type C_CellRendererEditingCanceledCallback =
        Ptr CellRenderer ->                     -- 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_CellRendererEditingCanceledCallback ::
        GObject a => (a -> CellRendererEditingCanceledCallback) ->
        C_CellRendererEditingCanceledCallback
    wrap_CellRendererEditingCanceledCallback :: forall a.
    GObject a =>
    (a -> IO ()) -> C_CellRendererEditingCanceledCallback
    wrap_CellRendererEditingCanceledCallback a -> IO ()
    gi'cb Ptr CellRenderer
    gi'selfPtr Ptr ()
    _ = do
        Ptr CellRenderer -> (CellRenderer -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr CellRenderer
    gi'selfPtr ((CellRenderer -> IO ()) -> IO ())
    -> (CellRenderer -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \CellRenderer
    gi'self -> a -> IO ()
    gi'cb (CellRenderer -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce CellRenderer
    gi'self)

    -- | 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 -> ((?self :: a) => CellRendererEditingCanceledCallback) -> m SignalHandlerId
    onCellRendererEditingCanceled :: forall a (m :: * -> *).
    (IsCellRenderer a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onCellRendererEditingCanceled a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_CellRendererEditingCanceledCallback
    wrapped' = (a -> IO ()) -> C_CellRendererEditingCanceledCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_CellRendererEditingCanceledCallback
    wrap_CellRendererEditingCanceledCallback a -> IO ()
    wrapped
        wrapped'' <- C_CellRendererEditingCanceledCallback
    -> IO (FunPtr C_CellRendererEditingCanceledCallback)
    mk_CellRendererEditingCanceledCallback C_CellRendererEditingCanceledCallback
    wrapped'
        connectSignalFunPtr obj "editing-canceled" wrapped'' SignalConnectBefore 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
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingCanceledCallback) -> m SignalHandlerId
    afterCellRendererEditingCanceled :: forall a (m :: * -> *).
    (IsCellRenderer a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterCellRendererEditingCanceled a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_CellRendererEditingCanceledCallback
    wrapped' = (a -> IO ()) -> C_CellRendererEditingCanceledCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_CellRendererEditingCanceledCallback
    wrap_CellRendererEditingCanceledCallback a -> IO ()
    wrapped
        wrapped'' <- C_CellRendererEditingCanceledCallback
    -> IO (FunPtr C_CellRendererEditingCanceledCallback)
    mk_CellRendererEditingCanceledCallback C_CellRendererEditingCanceledCallback
    wrapped'
        connectSignalFunPtr obj "editing-canceled" wrapped'' SignalConnectAfter 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
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer::editing-canceled"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:signal:editingCanceled"})

    #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 gchar     *path,
    -- >                      gpointer         data)
    -- >{
    -- >  if (GTK_IS_ENTRY (editable))
    -- >    {
    -- >      GtkEntry *entry = GTK_ENTRY (editable);
    -- >
    -- >      // ... create a GtkEntryCompletion
    -- >
    -- >      gtk_entry_set_completion (entry, completion);
    -- >    }
    -- >}
    --
    --
    -- /Since: 2.6/
    type CellRendererEditingStartedCallback =
        Gtk.CellEditable.CellEditable
        -- ^ /@editable@/: the t'GI.Gtk.Interfaces.CellEditable.CellEditable'
        -> T.Text
        -- ^ /@path@/: the path identifying the edited cell
        -> IO ()

    type C_CellRendererEditingStartedCallback =
        Ptr CellRenderer ->                     -- 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_CellRendererEditingStartedCallback ::
        GObject a => (a -> CellRendererEditingStartedCallback) ->
        C_CellRendererEditingStartedCallback
    wrap_CellRendererEditingStartedCallback :: forall a.
    GObject a =>
    (a -> CellRendererEditingStartedCallback)
    -> C_CellRendererEditingStartedCallback
    wrap_CellRendererEditingStartedCallback a -> CellRendererEditingStartedCallback
    gi'cb Ptr CellRenderer
    gi'selfPtr Ptr CellEditable
    editable CString
    path Ptr ()
    _ = do
        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
        path' <- cstringToText path
        B.ManagedPtr.withNewObject gi'selfPtr $ \CellRenderer
    gi'self -> a -> CellRendererEditingStartedCallback
    gi'cb (CellRenderer -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce CellRenderer
    gi'self)  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 -> ((?self :: a) => CellRendererEditingStartedCallback) -> m SignalHandlerId
    onCellRendererEditingStarted :: forall a (m :: * -> *).
    (IsCellRenderer a, MonadIO m) =>
    a
    -> ((?self::a) => CellRendererEditingStartedCallback)
    -> m SignalHandlerId
    onCellRendererEditingStarted a
    obj (?self::a) => CellRendererEditingStartedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> CellRendererEditingStartedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => CellRendererEditingStartedCallback
    CellRendererEditingStartedCallback
    cb
        let wrapped' :: C_CellRendererEditingStartedCallback
    wrapped' = (a -> CellRendererEditingStartedCallback)
    -> C_CellRendererEditingStartedCallback
    forall a.
    GObject a =>
    (a -> CellRendererEditingStartedCallback)
    -> C_CellRendererEditingStartedCallback
    wrap_CellRendererEditingStartedCallback a -> CellRendererEditingStartedCallback
    wrapped
        wrapped'' <- C_CellRendererEditingStartedCallback
    -> IO (FunPtr C_CellRendererEditingStartedCallback)
    mk_CellRendererEditingStartedCallback C_CellRendererEditingStartedCallback
    wrapped'
        connectSignalFunPtr obj "editing-started" wrapped'' SignalConnectBefore 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
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingStartedCallback) -> m SignalHandlerId
    afterCellRendererEditingStarted :: forall a (m :: * -> *).
    (IsCellRenderer a, MonadIO m) =>
    a
    -> ((?self::a) => CellRendererEditingStartedCallback)
    -> m SignalHandlerId
    afterCellRendererEditingStarted a
    obj (?self::a) => CellRendererEditingStartedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> CellRendererEditingStartedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => CellRendererEditingStartedCallback
    CellRendererEditingStartedCallback
    cb
        let wrapped' :: C_CellRendererEditingStartedCallback
    wrapped' = (a -> CellRendererEditingStartedCallback)
    -> C_CellRendererEditingStartedCallback
    forall a.
    GObject a =>
    (a -> CellRendererEditingStartedCallback)
    -> C_CellRendererEditingStartedCallback
    wrap_CellRendererEditingStartedCallback a -> CellRendererEditingStartedCallback
    wrapped
        wrapped'' <- C_CellRendererEditingStartedCallback
    -> IO (FunPtr C_CellRendererEditingStartedCallback)
    mk_CellRendererEditingStartedCallback C_CellRendererEditingStartedCallback
    wrapped'
        connectSignalFunPtr obj "editing-started" wrapped'' SignalConnectAfter 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
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer::editing-started"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:signal:editingStarted"})

    #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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe 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 t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe 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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe 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
        attrPut = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererCellBackground
        attrClear = clearCellRendererCellBackground
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellBackground"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:cellBackground"
            })
    #endif

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data CellRendererCellBackgroundGdkPropertyInfo
    instance AttrInfo CellRendererCellBackgroundGdkPropertyInfo where
        type AttrAllowedOps CellRendererCellBackgroundGdkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = IsCellRenderer
        type AttrSetTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = (~) Gdk.Color.Color
        type AttrTransferTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = (~) Gdk.Color.Color
        type AttrTransferType CellRendererCellBackgroundGdkPropertyInfo = Gdk.Color.Color
        type AttrGetType CellRendererCellBackgroundGdkPropertyInfo = (Maybe Gdk.Color.Color)
        type AttrLabel CellRendererCellBackgroundGdkPropertyInfo = "cell-background-gdk"
        type AttrOrigin CellRendererCellBackgroundGdkPropertyInfo = CellRenderer
        attrGet = getCellRendererCellBackgroundGdk
        attrSet = setCellRendererCellBackgroundGdk
        attrPut = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererCellBackgroundGdk
        attrClear = clearCellRendererCellBackgroundGdk
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellBackgroundGdk"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:cellBackgroundGdk"
            })
    #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 a. IO a -> m a
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe 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 t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe 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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Maybe 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
        attrPut = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererCellBackgroundRgba
        attrClear = clearCellRendererCellBackgroundRgba
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellBackgroundRgba"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:cellBackgroundRgba"
            })
    #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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "cell-background-set" Bool
    val

    -- | Construct a t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "cell-background-set" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data CellRendererCellBackgroundSetPropertyInfo
    instance AttrInfo CellRendererCellBackgroundSetPropertyInfo where
        type AttrAllowedOps CellRendererCellBackgroundSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        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
        attrPut = setCellRendererCellBackgroundSet
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererCellBackgroundSet
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellBackgroundSet"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:cellBackgroundSet"
            })
    #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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "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
        attrPut = undefined
        attrTransfer _ = undefined
        attrConstruct = undefined
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.editing"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:editing"
            })
    #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 a. IO a -> m a
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Int32 -> IO ()
    forall a. GObject a => a -> String -> Int32 -> IO ()
    B.Properties.setObjectPropertyInt32 o
    obj String
    "height" Int32
    val

    -- | Construct a t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> 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, 'AttrPut]
        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
        attrPut = setCellRendererHeight
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererHeight
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.height"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:height"
            })
    #endif

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

    -- | 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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "is-expanded" Bool
    val

    -- | Construct a t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "is-expanded" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data CellRendererIsExpandedPropertyInfo
    instance AttrInfo CellRendererIsExpandedPropertyInfo where
        type AttrAllowedOps CellRendererIsExpandedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        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
        attrPut = setCellRendererIsExpanded
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererIsExpanded
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.isExpanded"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:isExpanded"
            })
    #endif

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

    -- | 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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "is-expander" Bool
    val

    -- | Construct a t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "is-expander" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data CellRendererIsExpanderPropertyInfo
    instance AttrInfo CellRendererIsExpanderPropertyInfo where
        type AttrAllowedOps CellRendererIsExpanderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        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
        attrPut = setCellRendererIsExpander
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererIsExpander
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.isExpander"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:isExpander"
            })
    #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 a. IO a -> m a
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> 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 t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> 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, 'AttrPut]
        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
        attrPut = setCellRendererMode
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererMode
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.mode"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:mode"
            })
    #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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "sensitive" Bool
    val

    -- | Construct a t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "sensitive" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data CellRendererSensitivePropertyInfo
    instance AttrInfo CellRendererSensitivePropertyInfo where
        type AttrAllowedOps CellRendererSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        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
        attrPut = setCellRendererSensitive
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererSensitive
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.sensitive"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:sensitive"
            })
    #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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "visible" Bool
    val

    -- | Construct a t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "visible" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data CellRendererVisiblePropertyInfo
    instance AttrInfo CellRendererVisiblePropertyInfo where
        type AttrAllowedOps CellRendererVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        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
        attrPut = setCellRendererVisible
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererVisible
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.visible"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:visible"
            })
    #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 a. IO a -> m a
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Int32 -> IO ()
    forall a. GObject a => a -> String -> Int32 -> IO ()
    B.Properties.setObjectPropertyInt32 o
    obj String
    "width" Int32
    val

    -- | Construct a t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> 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, 'AttrPut]
        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
        attrPut = setCellRendererWidth
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererWidth
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.width"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:width"
            })
    #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 a. IO a -> m a
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Float -> IO ()
    forall a. GObject a => a -> String -> Float -> IO ()
    B.Properties.setObjectPropertyFloat o
    obj String
    "xalign" Float
    val

    -- | Construct a t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> 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, 'AttrPut]
        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
        attrPut = setCellRendererXalign
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererXalign
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.xalign"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:xalign"
            })
    #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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Word32
    forall a. GObject a => a -> String -> IO Word32
    B.Properties.getObjectPropertyUInt32 o
    obj String
    "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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Word32 -> IO ()
    forall a. GObject a => a -> String -> Word32 -> IO ()
    B.Properties.setObjectPropertyUInt32 o
    obj String
    "xpad" Word32
    val

    -- | Construct a t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Word32 -> IO (GValueConstruct o)
    forall o. String -> Word32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyUInt32 String
    "xpad" Word32
    val

    #if defined(ENABLE_OVERLOADING)
    data CellRendererXpadPropertyInfo
    instance AttrInfo CellRendererXpadPropertyInfo where
        type AttrAllowedOps CellRendererXpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        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
        attrPut = setCellRendererXpad
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererXpad
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.xpad"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:xpad"
            })
    #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 a. IO a -> m a
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Float -> IO ()
    forall a. GObject a => a -> String -> Float -> IO ()
    B.Properties.setObjectPropertyFloat o
    obj String
    "yalign" Float
    val

    -- | Construct a t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> 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, 'AttrPut]
        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
        attrPut = setCellRendererYalign
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererYalign
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.yalign"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:yalign"
            })
    #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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Word32
    forall a. GObject a => a -> String -> IO Word32
    B.Properties.getObjectPropertyUInt32 o
    obj String
    "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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Word32 -> IO ()
    forall a. GObject a => a -> String -> Word32 -> IO ()
    B.Properties.setObjectPropertyUInt32 o
    obj String
    "ypad" Word32
    val

    -- | Construct a t'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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Word32 -> IO (GValueConstruct o)
    forall o. String -> Word32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyUInt32 String
    "ypad" Word32
    val

    #if defined(ENABLE_OVERLOADING)
    data CellRendererYpadPropertyInfo
    instance AttrInfo CellRendererYpadPropertyInfo where
        type AttrAllowedOps CellRendererYpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        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
        attrPut = setCellRendererYpad
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererYpad
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.ypad"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#g:attr:ypad"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList CellRenderer
    type instance O.AttributeList CellRenderer = CellRendererAttributeList
    type CellRendererAttributeList = ('[ '("cellBackground", CellRendererCellBackgroundPropertyInfo), '("cellBackgroundGdk", CellRendererCellBackgroundGdkPropertyInfo), '("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, DK.Type)])
    #endif

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

    cellRendererCellBackgroundGdk :: AttrLabelProxy "cellBackgroundGdk"
    cellRendererCellBackgroundGdk = 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, DK.Type)])

    #endif

    -- method CellRenderer::activate
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "event"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Event" }
    --           , argCType = Just "GdkEvent*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkEvent" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "widget that received the event"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const gchar*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "background_area"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
    --           , argCType = Just "const GdkRectangle*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell_area"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
    --           , argCType = Just "const GdkRectangle*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRendererState" }
    --           , argCType = Just "GtkCellRendererState"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "render flags" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_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, Gtk.Widget.IsWidget b) =>
        a
        -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
        -> Gdk.Event.Event
        -- ^ /@event@/: a t'GI.Gdk.Unions.Event.Event'
        -> b
        -- ^ /@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 'GI.Gtk.Objects.CellRenderer.cellRendererRender'
        -> Gdk.Rectangle.Rectangle
        -- ^ /@cellArea@/: cell area as passed to 'GI.Gtk.Objects.CellRenderer.cellRendererRender'
        -> [Gtk.Flags.CellRendererState]
        -- ^ /@flags@/: render flags
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the event was consumed\/handled
    cellRendererActivate :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) =>
    a
    -> Event
    -> b
    -> Text
    -> Rectangle
    -> Rectangle
    -> [CellRendererState]
    -> m Bool
    cellRendererActivate a
    cell Event
    event b
    widget Text
    path Rectangle
    backgroundArea Rectangle
    cellArea [CellRendererState]
    flags = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        event' <- unsafeManagedPtrGetPtr event
        widget' <- unsafeManagedPtrCastPtr widget
        path' <- textToCString path
        backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea
        cellArea' <- unsafeManagedPtrGetPtr cellArea
        let flags' = [CellRendererState] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [CellRendererState]
    flags
        result <- gtk_cell_renderer_activate cell' event' widget' path' backgroundArea' cellArea' flags'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr cell
        touchManagedPtr event
        touchManagedPtr widget
        touchManagedPtr backgroundArea
        touchManagedPtr cellArea
        freeMem path'
        return result'

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

    instance O.OverloadedMethodInfo CellRendererActivateMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererActivate",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRenderer instance"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRendererState" }
    --           , argCType = Just "GtkCellRendererState"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "render flags" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell_area"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
    --           , argCType = Just "const GdkRectangle*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "aligned_area"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
    --           , argCType = Just "GdkRectangle*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the return location for the space inside @cell_area\n               that would acually be used to render."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = True
    --           , argCallbackUserData = False
    --           , 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.
    --
    -- /Since: 3.0/
    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 'GI.Gtk.Objects.CellRenderer.cellRendererRender'
        -> 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 a. IO a -> m a
    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
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        widget' <- unsafeManagedPtrCastPtr widget
        let flags' = [CellRendererState] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [CellRendererState]
    flags
        cellArea' <- unsafeManagedPtrGetPtr cellArea
        alignedArea <- SP.callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
        gtk_cell_renderer_get_aligned_area cell' widget' flags' cellArea' alignedArea
        alignedArea' <- (wrapBoxed Gdk.Rectangle.Rectangle) alignedArea
        touchManagedPtr cell
        touchManagedPtr widget
        touchManagedPtr cellArea
        return 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetAlignedArea",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "xalign"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "gfloat*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "yalign"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "gfloat*"
    --           , 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
    --           , argCallbackUserData = 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@/.
    --
    -- /Since: 2.18/
    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 a. IO a -> m a
    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
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        xalign <- allocMem :: IO (Ptr CFloat)
        yalign <- allocMem :: IO (Ptr CFloat)
        gtk_cell_renderer_get_alignment cell' xalign yalign
        xalign' <- peek xalign
        let xalign'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    xalign'
        yalign' <- peek yalign
        let yalign'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    yalign'
        touchManagedPtr cell
        freeMem xalign
        freeMem yalign
        return (xalign'', 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetAlignment",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "height"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , 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
    --           , argCallbackUserData = 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 a. IO a -> m a
    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
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        width <- allocMem :: IO (Ptr Int32)
        height <- allocMem :: IO (Ptr Int32)
        gtk_cell_renderer_get_fixed_size cell' width height
        width' <- peek width
        height' <- peek height
        touchManagedPtr cell
        freeMem width
        freeMem height
        return (width', 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetFixedSize",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetFixedSize"
            })

    #endif

    -- method CellRenderer::get_padding
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "xpad"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "ypad"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , 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
    --           , argCallbackUserData = 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@/.
    --
    -- /Since: 2.18/
    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 a. IO a -> m a
    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
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        xpad <- allocMem :: IO (Ptr Int32)
        ypad <- allocMem :: IO (Ptr Int32)
        gtk_cell_renderer_get_padding cell' xpad ypad
        xpad' <- peek xpad
        ypad' <- peek ypad
        touchManagedPtr cell
        freeMem xpad
        freeMem ypad
        return (xpad', 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetPadding",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRenderer instance"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "minimum_size"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "natural_size"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , 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
    --           , argCallbackUserData = 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 ()

    -- | Retreives a renderer’s natural size when rendered to /@widget@/.
    --
    -- /Since: 3.0/
    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 a. IO a -> m a
    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
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        widget' <- unsafeManagedPtrCastPtr widget
        minimumSize <- allocMem :: IO (Ptr Int32)
        naturalSize <- allocMem :: IO (Ptr Int32)
        gtk_cell_renderer_get_preferred_height cell' widget' minimumSize naturalSize
        minimumSize' <- peek minimumSize
        naturalSize' <- peek naturalSize
        touchManagedPtr cell
        touchManagedPtr widget
        freeMem minimumSize
        freeMem naturalSize
        return (minimumSize', 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredHeight",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRenderer instance"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "minimum_height"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "natural_height"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , 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
    --           , argCallbackUserData = 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 ()

    -- | Retreives a cell renderers’s minimum and natural height if it were rendered to
    -- /@widget@/ with the specified /@width@/.
    --
    -- /Since: 3.0/
    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 a. IO a -> m a
    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
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        widget' <- unsafeManagedPtrCastPtr widget
        minimumHeight <- allocMem :: IO (Ptr Int32)
        naturalHeight <- allocMem :: IO (Ptr Int32)
        gtk_cell_renderer_get_preferred_height_for_width cell' widget' width minimumHeight naturalHeight
        minimumHeight' <- peek minimumHeight
        naturalHeight' <- peek naturalHeight
        touchManagedPtr cell
        touchManagedPtr widget
        freeMem minimumHeight
        freeMem naturalHeight
        return (minimumHeight', 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredHeightForWidth",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRenderer instance"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "minimum_size"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Requisition" }
    --           , argCType = Just "GtkRequisition*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "natural_size"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Requisition" }
    --           , argCType = Just "GtkRequisition*"
    --           , 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
    --           , argCallbackUserData = False
    --           , 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.
    --
    -- /Since: 3.0/
    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 a. IO a -> m a
    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
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        widget' <- unsafeManagedPtrCastPtr widget
        minimumSize <- SP.callocBoxedBytes 8 :: IO (Ptr Gtk.Requisition.Requisition)
        naturalSize <- SP.callocBoxedBytes 8 :: IO (Ptr Gtk.Requisition.Requisition)
        gtk_cell_renderer_get_preferred_size cell' widget' minimumSize naturalSize
        minimumSize' <- (wrapBoxed Gtk.Requisition.Requisition) minimumSize
        naturalSize' <- (wrapBoxed Gtk.Requisition.Requisition) naturalSize
        touchManagedPtr cell
        touchManagedPtr widget
        return (minimumSize', 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredSize",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRenderer instance"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "minimum_size"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "natural_size"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , 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
    --           , argCallbackUserData = 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 ()

    -- | Retreives a renderer’s natural size when rendered to /@widget@/.
    --
    -- /Since: 3.0/
    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 a. IO a -> m a
    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
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        widget' <- unsafeManagedPtrCastPtr widget
        minimumSize <- allocMem :: IO (Ptr Int32)
        naturalSize <- allocMem :: IO (Ptr Int32)
        gtk_cell_renderer_get_preferred_width cell' widget' minimumSize naturalSize
        minimumSize' <- peek minimumSize
        naturalSize' <- peek naturalSize
        touchManagedPtr cell
        touchManagedPtr widget
        freeMem minimumSize
        freeMem naturalSize
        return (minimumSize', 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredWidth",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRenderer instance"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "height"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "minimum_width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "natural_width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , 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
    --           , argCallbackUserData = 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 ()

    -- | Retreives a cell renderers’s minimum and natural width if it were rendered to
    -- /@widget@/ with the specified /@height@/.
    --
    -- /Since: 3.0/
    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 a. IO a -> m a
    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
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        widget' <- unsafeManagedPtrCastPtr widget
        minimumWidth <- allocMem :: IO (Ptr Int32)
        naturalWidth <- allocMem :: IO (Ptr Int32)
        gtk_cell_renderer_get_preferred_width_for_height cell' widget' height minimumWidth naturalWidth
        minimumWidth' <- peek minimumWidth
        naturalWidth' <- peek naturalWidth
        touchManagedPtr cell
        touchManagedPtr widget
        freeMem minimumWidth
        freeMem naturalWidth
        return (minimumWidth', 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredWidthForHeight",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRenderer    instance"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = 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.
    --
    -- /Since: 3.0/
    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 a. IO a -> m a
    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
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        result <- gtk_cell_renderer_get_request_mode cell'
        let 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
        touchManagedPtr cell
        return 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetRequestMode",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_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.
    --
    -- /Since: 2.18/
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        result <- gtk_cell_renderer_get_sensitive cell'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr cell
        return 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetSensitive",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererGetSensitive"
            })

    #endif

    -- method CellRenderer::get_size
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the widget the renderer is rendering to"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell_area"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
    --           , argCType = Just "const GdkRectangle*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The area a cell will be allocated, or %NULL"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "x_offset"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "location to return x offset of cell relative to @cell_area, or %NULL"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "y_offset"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "location to return y offset of cell relative to @cell_area, or %NULL"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "location to return width needed to render a cell, or %NULL"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "height"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "location to return height needed to render a cell, or %NULL"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_cell_renderer_get_size" gtk_cell_renderer_get_size ::
        Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
        Ptr Gdk.Rectangle.Rectangle ->          -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
        Ptr Int32 ->                            -- x_offset : TBasicType TInt
        Ptr Int32 ->                            -- y_offset : TBasicType TInt
        Ptr Int32 ->                            -- width : TBasicType TInt
        Ptr Int32 ->                            -- height : TBasicType TInt
        IO ()

    {-# DEPRECATED cellRendererGetSize ["(Since version 3.0)","Use 'GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredSize' instead."] #-}
    -- | Obtains the width and height needed to render the cell. Used by view
    -- widgets to determine the appropriate size for the cell_area passed to
    -- 'GI.Gtk.Objects.CellRenderer.cellRendererRender'.  If /@cellArea@/ is not 'P.Nothing', fills in the
    -- x and y offsets (if set) of the cell relative to this location.
    --
    -- Please note that the values set in /@width@/ and /@height@/, as well as those
    -- in /@xOffset@/ and /@yOffset@/ are inclusive of the xpad and ypad properties.
    cellRendererGetSize ::
        (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
        a
        -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
        -> b
        -- ^ /@widget@/: the widget the renderer is rendering to
        -> Maybe (Gdk.Rectangle.Rectangle)
        -- ^ /@cellArea@/: The area a cell will be allocated, or 'P.Nothing'
        -> m ((Int32, Int32, Int32, Int32))
    cellRendererGetSize :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) =>
    a -> b -> Maybe Rectangle -> m (Int32, Int32, Int32, Int32)
    cellRendererGetSize a
    cell b
    widget Maybe Rectangle
    cellArea = IO (Int32, Int32, Int32, Int32) -> m (Int32, Int32, Int32, Int32)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Int32, Int32, Int32, Int32) -> m (Int32, Int32, Int32, Int32))
    -> IO (Int32, Int32, Int32, Int32)
    -> m (Int32, Int32, Int32, Int32)
    forall a b. (a -> b) -> a -> b
    $ do
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        widget' <- unsafeManagedPtrCastPtr widget
        maybeCellArea <- case cellArea of
            Maybe Rectangle
    Nothing -> Ptr Rectangle -> IO (Ptr Rectangle)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Rectangle
    forall a. Ptr a
    FP.nullPtr
            Just Rectangle
    jCellArea -> do
                jCellArea' <- Rectangle -> IO (Ptr Rectangle)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Rectangle
    jCellArea
                return jCellArea'
        xOffset <- allocMem :: IO (Ptr Int32)
        yOffset <- allocMem :: IO (Ptr Int32)
        width <- allocMem :: IO (Ptr Int32)
        height <- allocMem :: IO (Ptr Int32)
        gtk_cell_renderer_get_size cell' widget' maybeCellArea xOffset yOffset width height
        xOffset' <- peek xOffset
        yOffset' <- peek yOffset
        width' <- peek width
        height' <- peek height
        touchManagedPtr cell
        touchManagedPtr widget
        whenJust cellArea touchManagedPtr
        freeMem xOffset
        freeMem yOffset
        freeMem width
        freeMem height
        return (xOffset', yOffset', width', height')

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

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

    #endif

    -- method CellRenderer::get_state
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRenderer, or %NULL"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkWidget, or %NULL"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell_state"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRendererState" }
    --           , argCType = Just "GtkCellRendererState"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "cell renderer state"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = 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'.
    --
    -- /Since: 3.0/
    cellRendererGetState ::
        (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
        Maybe (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) =>
    Maybe a -> Maybe b -> [CellRendererState] -> m [StateFlags]
    cellRendererGetState Maybe a
    cell Maybe b
    widget [CellRendererState]
    cellState = IO [StateFlags] -> m [StateFlags]
    forall a. IO a -> m a
    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
        maybeCell <- case Maybe a
    cell of
            Maybe a
    Nothing -> Ptr CellRenderer -> IO (Ptr CellRenderer)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr CellRenderer
    forall a. Ptr a
    FP.nullPtr
            Just a
    jCell -> do
                jCell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    jCell
                return jCell'
        maybeWidget <- case widget of
            Maybe b
    Nothing -> Ptr Widget -> IO (Ptr Widget)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Widget
    forall a. Ptr a
    FP.nullPtr
            Just b
    jWidget -> do
                jWidget' <- b -> IO (Ptr Widget)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jWidget
                return jWidget'
        let cellState' = [CellRendererState] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [CellRendererState]
    cellState
        result <- gtk_cell_renderer_get_state maybeCell maybeWidget cellState'
        let result' = CUInt -> [StateFlags]
    forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
    wordToGFlags CUInt
    result
        whenJust cell touchManagedPtr
        whenJust widget touchManagedPtr
        return 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 i = cellRendererGetState (Just i)

    instance O.OverloadedMethodInfo CellRendererGetStateMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetState",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_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.
    --
    -- /Since: 2.18/
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        result <- gtk_cell_renderer_get_visible cell'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr cell
        return 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererGetVisible",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_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.
    --
    -- /Since: 3.0/
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        result <- gtk_cell_renderer_is_activatable cell'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr cell
        return 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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererIsActivatable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererIsActivatable"
            })

    #endif

    -- method CellRenderer::render
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cr"
    --           , argType =
    --               TInterface Name { namespace = "cairo" , name = "Context" }
    --           , argCType = Just "cairo_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a cairo context to draw to"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the widget owning @window"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "background_area"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
    --           , argCType = Just "const GdkRectangle*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell_area"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
    --           , argCType = Just "const GdkRectangle*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRendererState" }
    --           , argCType = Just "GtkCellRendererState"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "flags that affect rendering"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_cell_renderer_render" gtk_cell_renderer_render ::
        Ptr CellRenderer ->                     -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"})
        Ptr Cairo.Context.Context ->            -- cr : TInterface (Name {namespace = "cairo", name = "Context"})
        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@/.
    cellRendererRender ::
        (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
        a
        -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
        -> Cairo.Context.Context
        -- ^ /@cr@/: a cairo context to draw to
        -> b
        -- ^ /@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 ()
    cellRendererRender :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) =>
    a
    -> Context
    -> b
    -> Rectangle
    -> Rectangle
    -> [CellRendererState]
    -> m ()
    cellRendererRender a
    cell Context
    cr b
    widget Rectangle
    backgroundArea Rectangle
    cellArea [CellRendererState]
    flags = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        cr' <- unsafeManagedPtrGetPtr cr
        widget' <- unsafeManagedPtrCastPtr widget
        backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea
        cellArea' <- unsafeManagedPtrGetPtr cellArea
        let flags' = [CellRendererState] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [CellRendererState]
    flags
        gtk_cell_renderer_render cell' cr' widget' backgroundArea' cellArea' flags'
        touchManagedPtr cell
        touchManagedPtr cr
        touchManagedPtr widget
        touchManagedPtr backgroundArea
        touchManagedPtr cellArea
        return ()

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

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

    #endif

    -- method CellRenderer::set_alignment
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "xalign"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "gfloat"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "yalign"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "gfloat"
    --           , 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
    --           , argCallbackUserData = 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.
    --
    -- /Since: 2.18/
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        let xalign' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    xalign
        let yalign' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    yalign
        gtk_cell_renderer_set_alignment cell' xalign' yalign'
        touchManagedPtr cell
        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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererSetAlignment",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "width"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "height"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint"
    --           , 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
    --           , argCallbackUserData = 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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        gtk_cell_renderer_set_fixed_size cell' width height
        touchManagedPtr cell
        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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererSetFixedSize",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererSetFixedSize"
            })

    #endif

    -- method CellRenderer::set_padding
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "xpad"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "ypad"
    --           , argType = TBasicType TInt
    --           , argCType = Just "gint"
    --           , 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
    --           , argCallbackUserData = 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.
    --
    -- /Since: 2.18/
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        gtk_cell_renderer_set_padding cell' xpad ypad
        touchManagedPtr cell
        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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererSetPadding",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "sensitive"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the sensitivity of the cell"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_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.
    --
    -- /Since: 2.18/
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        let sensitive' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    sensitive
        gtk_cell_renderer_set_sensitive cell' sensitive'
        touchManagedPtr cell
        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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererSetSensitive",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "visible"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the visibility of the cell"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_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.
    --
    -- /Since: 2.18/
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        let visible' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    visible
        gtk_cell_renderer_set_visible cell' visible'
        touchManagedPtr cell
        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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererSetVisible",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererSetVisible"
            })

    #endif

    -- method CellRenderer::start_editing
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cell"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRenderer" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "event"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Event" }
    --           , argCType = Just "GdkEvent*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkEvent" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "widget"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
    --           , argCType = Just "GtkWidget*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "widget that received the event"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const gchar*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "background_area"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
    --           , argCType = Just "const GdkRectangle*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cell_area"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
    --           , argCType = Just "const GdkRectangle*"
    --           , 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
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRendererState" }
    --           , argCType = Just "GtkCellRendererState"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "render flags" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = 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, Gtk.Widget.IsWidget b) =>
        a
        -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
        -> Maybe (Gdk.Event.Event)
        -- ^ /@event@/: a t'GI.Gdk.Unions.Event.Event'
        -> b
        -- ^ /@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 'GI.Gtk.Objects.CellRenderer.cellRendererRender'
        -> Gdk.Rectangle.Rectangle
        -- ^ /@cellArea@/: cell area as passed to 'GI.Gtk.Objects.CellRenderer.cellRendererRender'
        -> [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.
    (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) =>
    a
    -> Maybe Event
    -> b
    -> Text
    -> Rectangle
    -> Rectangle
    -> [CellRendererState]
    -> m (Maybe CellEditable)
    cellRendererStartEditing a
    cell Maybe Event
    event b
    widget Text
    path Rectangle
    backgroundArea Rectangle
    cellArea [CellRendererState]
    flags = IO (Maybe CellEditable) -> m (Maybe CellEditable)
    forall a. IO a -> m a
    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
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        maybeEvent <- case event of
            Maybe Event
    Nothing -> Ptr Event -> IO (Ptr Event)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Event
    forall a. Ptr a
    FP.nullPtr
            Just Event
    jEvent -> do
                jEvent' <- Event -> IO (Ptr Event)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Event
    jEvent
                return jEvent'
        widget' <- unsafeManagedPtrCastPtr widget
        path' <- textToCString path
        backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea
        cellArea' <- unsafeManagedPtrGetPtr cellArea
        let flags' = [CellRendererState] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [CellRendererState]
    flags
        result <- gtk_cell_renderer_start_editing cell' maybeEvent widget' path' backgroundArea' cellArea' flags'
        maybeResult <- convertIfNonNull result $ \Ptr CellEditable
    result' -> do
            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'
            return result''
        touchManagedPtr cell
        whenJust event touchManagedPtr
        touchManagedPtr widget
        touchManagedPtr backgroundArea
        touchManagedPtr cellArea
        freeMem path'
        return maybeResult

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

    instance O.OverloadedMethodInfo CellRendererStartEditingMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererStartEditing",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/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" }
    --           , argCType = Just "GtkCellRenderer*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A #GtkCellRenderer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "canceled"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , 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
    --           , argCallbackUserData = 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
    -- [CellRenderer::editingCanceled]("GI.Gtk.Objects.CellRenderer#g:signal:editingCanceled") signal.
    --
    -- This function should be called by cell renderer implementations
    -- in response to the [CellEditable::editingDone]("GI.Gtk.Interfaces.CellEditable#g:signal:editingDone") signal of
    -- t'GI.Gtk.Interfaces.CellEditable.CellEditable'.
    --
    -- /Since: 2.6/
    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 a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        cell' <- a -> IO (Ptr CellRenderer)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cell
        let canceled' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    canceled
        gtk_cell_renderer_stop_editing cell' canceled'
        touchManagedPtr cell
        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 = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRenderer.cellRendererStopEditing",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CellRenderer.html#v:cellRendererStopEditing"
            })

    #endif