{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

The 'GI.Gtk.Objects.CellRenderer.CellRenderer' is a base class of a set of objects used for
rendering a cell to a 'GI.Cairo.Structs.Context.Context'.  These objects are used primarily by
the 'GI.Gtk.Objects.TreeView.TreeView' widget, though they aren’t tied to them in any
specific way.  It is worth noting that 'GI.Gtk.Objects.CellRenderer.CellRenderer' is not a
'GI.Gtk.Objects.Widget.Widget' and cannot be treated as such.

The primary use of a 'GI.Gtk.Objects.CellRenderer.CellRenderer' is for drawing a certain graphical
elements on a '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
'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 'GI.Gtk.Objects.Style.Style' change.  The '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 'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle',
which toggles when it gets activated by a mouse click, or it can be
“editable” like 'GI.Gtk.Objects.CellRendererText.CellRendererText', which
allows the user to edit the text using a widget implementing the
'GI.Gtk.Interfaces.CellEditable.CellEditable' interface, e.g. 'GI.Gtk.Objects.Entry.Entry'.
To make a cell renderer activatable or editable, you have to
implement the 'GI.Gtk.Structs.CellRendererClass.CellRendererClass'.@/activate/@ or
'GI.Gtk.Structs.CellRendererClass.CellRendererClass'.@/start_editing/@ virtual functions, respectively.

Many properties of '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.
-}

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

module GI.Gtk.Objects.CellRenderer
    (

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


 -- * Methods
-- ** activate #method:activate#

#if ENABLE_OVERLOADING
    CellRendererActivateMethodInfo          ,
#endif
    cellRendererActivate                    ,


-- ** getAlignedArea #method:getAlignedArea#

#if ENABLE_OVERLOADING
    CellRendererGetAlignedAreaMethodInfo    ,
#endif
    cellRendererGetAlignedArea              ,


-- ** getAlignment #method:getAlignment#

#if ENABLE_OVERLOADING
    CellRendererGetAlignmentMethodInfo      ,
#endif
    cellRendererGetAlignment                ,


-- ** getFixedSize #method:getFixedSize#

#if ENABLE_OVERLOADING
    CellRendererGetFixedSizeMethodInfo      ,
#endif
    cellRendererGetFixedSize                ,


-- ** getPadding #method:getPadding#

#if ENABLE_OVERLOADING
    CellRendererGetPaddingMethodInfo        ,
#endif
    cellRendererGetPadding                  ,


-- ** getPreferredHeight #method:getPreferredHeight#

#if ENABLE_OVERLOADING
    CellRendererGetPreferredHeightMethodInfo,
#endif
    cellRendererGetPreferredHeight          ,


-- ** getPreferredHeightForWidth #method:getPreferredHeightForWidth#

#if ENABLE_OVERLOADING
    CellRendererGetPreferredHeightForWidthMethodInfo,
#endif
    cellRendererGetPreferredHeightForWidth  ,


-- ** getPreferredSize #method:getPreferredSize#

#if ENABLE_OVERLOADING
    CellRendererGetPreferredSizeMethodInfo  ,
#endif
    cellRendererGetPreferredSize            ,


-- ** getPreferredWidth #method:getPreferredWidth#

#if ENABLE_OVERLOADING
    CellRendererGetPreferredWidthMethodInfo ,
#endif
    cellRendererGetPreferredWidth           ,


-- ** getPreferredWidthForHeight #method:getPreferredWidthForHeight#

#if ENABLE_OVERLOADING
    CellRendererGetPreferredWidthForHeightMethodInfo,
#endif
    cellRendererGetPreferredWidthForHeight  ,


-- ** getRequestMode #method:getRequestMode#

#if ENABLE_OVERLOADING
    CellRendererGetRequestModeMethodInfo    ,
#endif
    cellRendererGetRequestMode              ,


-- ** getSensitive #method:getSensitive#

#if ENABLE_OVERLOADING
    CellRendererGetSensitiveMethodInfo      ,
#endif
    cellRendererGetSensitive                ,


-- ** getSize #method:getSize#

#if ENABLE_OVERLOADING
    CellRendererGetSizeMethodInfo           ,
#endif
    cellRendererGetSize                     ,


-- ** getState #method:getState#

#if ENABLE_OVERLOADING
    CellRendererGetStateMethodInfo          ,
#endif
    cellRendererGetState                    ,


-- ** getVisible #method:getVisible#

#if ENABLE_OVERLOADING
    CellRendererGetVisibleMethodInfo        ,
#endif
    cellRendererGetVisible                  ,


-- ** isActivatable #method:isActivatable#

#if ENABLE_OVERLOADING
    CellRendererIsActivatableMethodInfo     ,
#endif
    cellRendererIsActivatable               ,


-- ** render #method:render#

#if ENABLE_OVERLOADING
    CellRendererRenderMethodInfo            ,
#endif
    cellRendererRender                      ,


-- ** setAlignment #method:setAlignment#

#if ENABLE_OVERLOADING
    CellRendererSetAlignmentMethodInfo      ,
#endif
    cellRendererSetAlignment                ,


-- ** setFixedSize #method:setFixedSize#

#if ENABLE_OVERLOADING
    CellRendererSetFixedSizeMethodInfo      ,
#endif
    cellRendererSetFixedSize                ,


-- ** setPadding #method:setPadding#

#if ENABLE_OVERLOADING
    CellRendererSetPaddingMethodInfo        ,
#endif
    cellRendererSetPadding                  ,


-- ** setSensitive #method:setSensitive#

#if ENABLE_OVERLOADING
    CellRendererSetSensitiveMethodInfo      ,
#endif
    cellRendererSetSensitive                ,


-- ** setVisible #method:setVisible#

#if ENABLE_OVERLOADING
    CellRendererSetVisibleMethodInfo        ,
#endif
    cellRendererSetVisible                  ,


-- ** startEditing #method:startEditing#

#if ENABLE_OVERLOADING
    CellRendererStartEditingMethodInfo      ,
#endif
    cellRendererStartEditing                ,


-- ** stopEditing #method:stopEditing#

#if ENABLE_OVERLOADING
    CellRendererStopEditingMethodInfo       ,
#endif
    cellRendererStopEditing                 ,




 -- * Properties
-- ** cellBackground #attr:cellBackground#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererCellBackgroundPropertyInfo  ,
#endif
#if ENABLE_OVERLOADING
    cellRendererCellBackground              ,
#endif
    clearCellRendererCellBackground         ,
    constructCellRendererCellBackground     ,
    setCellRendererCellBackground           ,


-- ** cellBackgroundGdk #attr:cellBackgroundGdk#
{- | Cell background as a 'GI.Gdk.Structs.Color.Color'
-}
#if ENABLE_OVERLOADING
    CellRendererCellBackgroundGdkPropertyInfo,
#endif
#if ENABLE_OVERLOADING
    cellRendererCellBackgroundGdk           ,
#endif
    clearCellRendererCellBackgroundGdk      ,
    constructCellRendererCellBackgroundGdk  ,
    getCellRendererCellBackgroundGdk        ,
    setCellRendererCellBackgroundGdk        ,


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

/Since: 3.0/
-}
#if ENABLE_OVERLOADING
    CellRendererCellBackgroundRgbaPropertyInfo,
#endif
#if ENABLE_OVERLOADING
    cellRendererCellBackgroundRgba          ,
#endif
    clearCellRendererCellBackgroundRgba     ,
    constructCellRendererCellBackgroundRgba ,
    getCellRendererCellBackgroundRgba       ,
    setCellRendererCellBackgroundRgba       ,


-- ** cellBackgroundSet #attr:cellBackgroundSet#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererCellBackgroundSetPropertyInfo,
#endif
#if ENABLE_OVERLOADING
    cellRendererCellBackgroundSet           ,
#endif
    constructCellRendererCellBackgroundSet  ,
    getCellRendererCellBackgroundSet        ,
    setCellRendererCellBackgroundSet        ,


-- ** editing #attr:editing#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererEditingPropertyInfo         ,
#endif
#if ENABLE_OVERLOADING
    cellRendererEditing                     ,
#endif
    getCellRendererEditing                  ,


-- ** height #attr:height#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererHeightPropertyInfo          ,
#endif
#if ENABLE_OVERLOADING
    cellRendererHeight                      ,
#endif
    constructCellRendererHeight             ,
    getCellRendererHeight                   ,
    setCellRendererHeight                   ,


-- ** isExpanded #attr:isExpanded#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererIsExpandedPropertyInfo      ,
#endif
#if ENABLE_OVERLOADING
    cellRendererIsExpanded                  ,
#endif
    constructCellRendererIsExpanded         ,
    getCellRendererIsExpanded               ,
    setCellRendererIsExpanded               ,


-- ** isExpander #attr:isExpander#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererIsExpanderPropertyInfo      ,
#endif
#if ENABLE_OVERLOADING
    cellRendererIsExpander                  ,
#endif
    constructCellRendererIsExpander         ,
    getCellRendererIsExpander               ,
    setCellRendererIsExpander               ,


-- ** mode #attr:mode#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererModePropertyInfo            ,
#endif
#if ENABLE_OVERLOADING
    cellRendererMode                        ,
#endif
    constructCellRendererMode               ,
    getCellRendererMode                     ,
    setCellRendererMode                     ,


-- ** sensitive #attr:sensitive#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererSensitivePropertyInfo       ,
#endif
#if ENABLE_OVERLOADING
    cellRendererSensitive                   ,
#endif
    constructCellRendererSensitive          ,
    getCellRendererSensitive                ,
    setCellRendererSensitive                ,


-- ** visible #attr:visible#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererVisiblePropertyInfo         ,
#endif
#if ENABLE_OVERLOADING
    cellRendererVisible                     ,
#endif
    constructCellRendererVisible            ,
    getCellRendererVisible                  ,
    setCellRendererVisible                  ,


-- ** width #attr:width#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererWidthPropertyInfo           ,
#endif
#if ENABLE_OVERLOADING
    cellRendererWidth                       ,
#endif
    constructCellRendererWidth              ,
    getCellRendererWidth                    ,
    setCellRendererWidth                    ,


-- ** xalign #attr:xalign#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererXalignPropertyInfo          ,
#endif
#if ENABLE_OVERLOADING
    cellRendererXalign                      ,
#endif
    constructCellRendererXalign             ,
    getCellRendererXalign                   ,
    setCellRendererXalign                   ,


-- ** xpad #attr:xpad#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererXpadPropertyInfo            ,
#endif
#if ENABLE_OVERLOADING
    cellRendererXpad                        ,
#endif
    constructCellRendererXpad               ,
    getCellRendererXpad                     ,
    setCellRendererXpad                     ,


-- ** yalign #attr:yalign#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererYalignPropertyInfo          ,
#endif
#if ENABLE_OVERLOADING
    cellRendererYalign                      ,
#endif
    constructCellRendererYalign             ,
    getCellRendererYalign                   ,
    setCellRendererYalign                   ,


-- ** ypad #attr:ypad#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CellRendererYpadPropertyInfo            ,
#endif
#if ENABLE_OVERLOADING
    cellRendererYpad                        ,
#endif
    constructCellRendererYpad               ,
    getCellRendererYpad                     ,
    setCellRendererYpad                     ,




 -- * Signals
-- ** editingCanceled #signal:editingCanceled#

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


-- ** editingStarted #signal:editingStarted#

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




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified 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

-- | Memory-managed wrapper type.
newtype CellRenderer = CellRenderer (ManagedPtr CellRenderer)
foreign import ccall "gtk_cell_renderer_get_type"
    c_gtk_cell_renderer_get_type :: IO GType

instance GObject CellRenderer where
    gobjectType = c_gtk_cell_renderer_get_type


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

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

-- | Cast to `CellRenderer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toCellRenderer :: (MonadIO m, IsCellRenderer o) => o -> m CellRenderer
toCellRenderer = liftIO . unsafeCastTo CellRenderer

-- | A convenience alias for `Nothing` :: `Maybe` `CellRenderer`.
noCellRenderer :: Maybe CellRenderer
noCellRenderer = Nothing

#if ENABLE_OVERLOADING
type family ResolveCellRendererMethod (t :: Symbol) (o :: *) :: * where
    ResolveCellRendererMethod "activate" o = CellRendererActivateMethodInfo
    ResolveCellRendererMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCellRendererMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCellRendererMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCellRendererMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCellRendererMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveCellRendererMethod "isActivatable" o = CellRendererIsActivatableMethodInfo
    ResolveCellRendererMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCellRendererMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCellRendererMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCellRendererMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCellRendererMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCellRendererMethod "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.MethodInfo info CellRenderer p) => OL.IsLabel t (CellRenderer -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#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 ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `CellRendererEditingCanceledCallback`@.
noCellRendererEditingCanceledCallback :: Maybe CellRendererEditingCanceledCallback
noCellRendererEditingCanceledCallback = Nothing

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

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

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


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


{- |
Connect a signal handler for the “@editing-canceled@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' cellRenderer #editingCanceled callback
@
-}
onCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingCanceledCallback -> m SignalHandlerId
onCellRendererEditingCanceled obj cb = liftIO $ do
    let cb' = wrap_CellRendererEditingCanceledCallback cb
    cb'' <- mk_CellRendererEditingCanceledCallback cb'
    connectSignalFunPtr obj "editing-canceled" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@editing-canceled@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' cellRenderer #editingCanceled callback
@
-}
afterCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingCanceledCallback -> m SignalHandlerId
afterCellRendererEditingCanceled obj cb = liftIO $ do
    let cb' = wrap_CellRendererEditingCanceledCallback cb
    cb'' <- mk_CellRendererEditingCanceledCallback cb'
    connectSignalFunPtr obj "editing-canceled" cb'' SignalConnectAfter


-- 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 'GI.Gtk.Objects.EntryCompletion.EntryCompletion' or setting
up additional columns in a '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 'GI.Gtk.Interfaces.CellEditable.CellEditable' -}
    -> T.Text
    {- ^ /@path@/: the path identifying the edited cell -}
    -> IO ()

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

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

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

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


-- | Wrap a `CellRendererEditingStartedCallback` into a `C_CellRendererEditingStartedCallback`.
wrap_CellRendererEditingStartedCallback ::
    CellRendererEditingStartedCallback ->
    C_CellRendererEditingStartedCallback
wrap_CellRendererEditingStartedCallback _cb _ editable path _ = do
    editable' <- (newObject Gtk.CellEditable.CellEditable) editable
    path' <- cstringToText path
    _cb  editable' path'


{- |
Connect a signal handler for the “@editing-started@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' cellRenderer #editingStarted callback
@
-}
onCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingStartedCallback -> m SignalHandlerId
onCellRendererEditingStarted obj cb = liftIO $ do
    let cb' = wrap_CellRendererEditingStartedCallback cb
    cb'' <- mk_CellRendererEditingStartedCallback cb'
    connectSignalFunPtr obj "editing-started" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@editing-started@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' cellRenderer #editingStarted callback
@
-}
afterCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingStartedCallback -> m SignalHandlerId
afterCellRendererEditingStarted obj cb = liftIO $ do
    let cb' = wrap_CellRendererEditingStartedCallback cb
    cb'' <- mk_CellRendererEditingStartedCallback cb'
    connectSignalFunPtr obj "editing-started" cb'' SignalConnectAfter


-- 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 obj val = liftIO $ B.Properties.setObjectPropertyString obj "cell-background" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@cell-background@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererCellBackground :: (IsCellRenderer o) => T.Text -> IO (GValueConstruct o)
constructCellRendererCellBackground val = B.Properties.constructObjectPropertyString "cell-background" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyString obj "cell-background" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data CellRendererCellBackgroundPropertyInfo
instance AttrInfo CellRendererCellBackgroundPropertyInfo where
    type AttrAllowedOps CellRendererCellBackgroundPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrClear]
    type AttrSetTypeConstraint CellRendererCellBackgroundPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CellRendererCellBackgroundPropertyInfo = IsCellRenderer
    type AttrGetType CellRendererCellBackgroundPropertyInfo = ()
    type AttrLabel CellRendererCellBackgroundPropertyInfo = "cell-background"
    type AttrOrigin CellRendererCellBackgroundPropertyInfo = CellRenderer
    attrGet _ = undefined
    attrSet _ = setCellRendererCellBackground
    attrConstruct _ = constructCellRendererCellBackground
    attrClear _ = clearCellRendererCellBackground
#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 obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "cell-background-gdk" 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 obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "cell-background-gdk" (Just val)

{- |
Construct a `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) => Gdk.Color.Color -> IO (GValueConstruct o)
constructCellRendererCellBackgroundGdk val = B.Properties.constructObjectPropertyBoxed "cell-background-gdk" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "cell-background-gdk" (Nothing :: Maybe Gdk.Color.Color)

#if ENABLE_OVERLOADING
data CellRendererCellBackgroundGdkPropertyInfo
instance AttrInfo CellRendererCellBackgroundGdkPropertyInfo where
    type AttrAllowedOps CellRendererCellBackgroundGdkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = (~) Gdk.Color.Color
    type AttrBaseTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = IsCellRenderer
    type AttrGetType CellRendererCellBackgroundGdkPropertyInfo = (Maybe Gdk.Color.Color)
    type AttrLabel CellRendererCellBackgroundGdkPropertyInfo = "cell-background-gdk"
    type AttrOrigin CellRendererCellBackgroundGdkPropertyInfo = CellRenderer
    attrGet _ = getCellRendererCellBackgroundGdk
    attrSet _ = setCellRendererCellBackgroundGdk
    attrConstruct _ = constructCellRendererCellBackgroundGdk
    attrClear _ = clearCellRendererCellBackgroundGdk
#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 obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "cell-background-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 obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "cell-background-rgba" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@cell-background-rgba@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererCellBackgroundRgba :: (IsCellRenderer o) => Gdk.RGBA.RGBA -> IO (GValueConstruct o)
constructCellRendererCellBackgroundRgba val = B.Properties.constructObjectPropertyBoxed "cell-background-rgba" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "cell-background-rgba" (Nothing :: Maybe Gdk.RGBA.RGBA)

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

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

{- |
Get the value of the “@cell-background-set@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cellRenderer #cellBackgroundSet
@
-}
getCellRendererCellBackgroundSet :: (MonadIO m, IsCellRenderer o) => o -> m Bool
getCellRendererCellBackgroundSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "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 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "cell-background-set" val

{- |
Construct a `GValueConstruct` with valid value for the “@cell-background-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererCellBackgroundSet :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o)
constructCellRendererCellBackgroundSet val = B.Properties.constructObjectPropertyBool "cell-background-set" val

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

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

{- |
Get the value of the “@editing@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cellRenderer #editing
@
-}
getCellRendererEditing :: (MonadIO m, IsCellRenderer o) => o -> m Bool
getCellRendererEditing obj = liftIO $ B.Properties.getObjectPropertyBool obj "editing"

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

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

{- |
Get the value of the “@height@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cellRenderer #height
@
-}
getCellRendererHeight :: (MonadIO m, IsCellRenderer o) => o -> m Int32
getCellRendererHeight obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "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 obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "height" val

{- |
Construct a `GValueConstruct` with valid value for the “@height@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererHeight :: (IsCellRenderer o) => Int32 -> IO (GValueConstruct o)
constructCellRendererHeight val = B.Properties.constructObjectPropertyInt32 "height" val

#if ENABLE_OVERLOADING
data CellRendererHeightPropertyInfo
instance AttrInfo CellRendererHeightPropertyInfo where
    type AttrAllowedOps CellRendererHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererHeightPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint CellRendererHeightPropertyInfo = IsCellRenderer
    type AttrGetType CellRendererHeightPropertyInfo = Int32
    type AttrLabel CellRendererHeightPropertyInfo = "height"
    type AttrOrigin CellRendererHeightPropertyInfo = CellRenderer
    attrGet _ = getCellRendererHeight
    attrSet _ = setCellRendererHeight
    attrConstruct _ = constructCellRendererHeight
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "is-expanded" val

{- |
Construct a `GValueConstruct` with valid value for the “@is-expanded@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererIsExpanded :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o)
constructCellRendererIsExpanded val = B.Properties.constructObjectPropertyBool "is-expanded" val

#if ENABLE_OVERLOADING
data CellRendererIsExpandedPropertyInfo
instance AttrInfo CellRendererIsExpandedPropertyInfo where
    type AttrAllowedOps CellRendererIsExpandedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererIsExpandedPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint CellRendererIsExpandedPropertyInfo = IsCellRenderer
    type AttrGetType CellRendererIsExpandedPropertyInfo = Bool
    type AttrLabel CellRendererIsExpandedPropertyInfo = "is-expanded"
    type AttrOrigin CellRendererIsExpandedPropertyInfo = CellRenderer
    attrGet _ = getCellRendererIsExpanded
    attrSet _ = setCellRendererIsExpanded
    attrConstruct _ = constructCellRendererIsExpanded
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyBool obj "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 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "is-expander" val

{- |
Construct a `GValueConstruct` with valid value for the “@is-expander@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererIsExpander :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o)
constructCellRendererIsExpander val = B.Properties.constructObjectPropertyBool "is-expander" val

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

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

{- |
Get the value of the “@mode@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cellRenderer #mode
@
-}
getCellRendererMode :: (MonadIO m, IsCellRenderer o) => o -> m Gtk.Enums.CellRendererMode
getCellRendererMode obj = liftIO $ B.Properties.getObjectPropertyEnum obj "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 obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "mode" val

{- |
Construct a `GValueConstruct` with valid value for the “@mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererMode :: (IsCellRenderer o) => Gtk.Enums.CellRendererMode -> IO (GValueConstruct o)
constructCellRendererMode val = B.Properties.constructObjectPropertyEnum "mode" val

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

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

{- |
Get the value of the “@sensitive@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cellRenderer #sensitive
@
-}
getCellRendererSensitive :: (MonadIO m, IsCellRenderer o) => o -> m Bool
getCellRendererSensitive obj = liftIO $ B.Properties.getObjectPropertyBool obj "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 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "sensitive" val

{- |
Construct a `GValueConstruct` with valid value for the “@sensitive@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererSensitive :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o)
constructCellRendererSensitive val = B.Properties.constructObjectPropertyBool "sensitive" val

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

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

{- |
Get the value of the “@visible@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cellRenderer #visible
@
-}
getCellRendererVisible :: (MonadIO m, IsCellRenderer o) => o -> m Bool
getCellRendererVisible obj = liftIO $ B.Properties.getObjectPropertyBool obj "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 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "visible" val

{- |
Construct a `GValueConstruct` with valid value for the “@visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererVisible :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o)
constructCellRendererVisible val = B.Properties.constructObjectPropertyBool "visible" val

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

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

{- |
Get the value of the “@width@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cellRenderer #width
@
-}
getCellRendererWidth :: (MonadIO m, IsCellRenderer o) => o -> m Int32
getCellRendererWidth obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "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 obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "width" val

{- |
Construct a `GValueConstruct` with valid value for the “@width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererWidth :: (IsCellRenderer o) => Int32 -> IO (GValueConstruct o)
constructCellRendererWidth val = B.Properties.constructObjectPropertyInt32 "width" val

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

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

{- |
Get the value of the “@xalign@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cellRenderer #xalign
@
-}
getCellRendererXalign :: (MonadIO m, IsCellRenderer o) => o -> m Float
getCellRendererXalign obj = liftIO $ B.Properties.getObjectPropertyFloat obj "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 obj val = liftIO $ B.Properties.setObjectPropertyFloat obj "xalign" val

{- |
Construct a `GValueConstruct` with valid value for the “@xalign@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererXalign :: (IsCellRenderer o) => Float -> IO (GValueConstruct o)
constructCellRendererXalign val = B.Properties.constructObjectPropertyFloat "xalign" val

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

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

{- |
Get the value of the “@xpad@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cellRenderer #xpad
@
-}
getCellRendererXpad :: (MonadIO m, IsCellRenderer o) => o -> m Word32
getCellRendererXpad obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "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 obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "xpad" val

{- |
Construct a `GValueConstruct` with valid value for the “@xpad@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererXpad :: (IsCellRenderer o) => Word32 -> IO (GValueConstruct o)
constructCellRendererXpad val = B.Properties.constructObjectPropertyUInt32 "xpad" val

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

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

{- |
Get the value of the “@yalign@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cellRenderer #yalign
@
-}
getCellRendererYalign :: (MonadIO m, IsCellRenderer o) => o -> m Float
getCellRendererYalign obj = liftIO $ B.Properties.getObjectPropertyFloat obj "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 obj val = liftIO $ B.Properties.setObjectPropertyFloat obj "yalign" val

{- |
Construct a `GValueConstruct` with valid value for the “@yalign@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererYalign :: (IsCellRenderer o) => Float -> IO (GValueConstruct o)
constructCellRendererYalign val = B.Properties.constructObjectPropertyFloat "yalign" val

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

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

{- |
Get the value of the “@ypad@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cellRenderer #ypad
@
-}
getCellRendererYpad :: (MonadIO m, IsCellRenderer o) => o -> m Word32
getCellRendererYpad obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "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 obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "ypad" val

{- |
Construct a `GValueConstruct` with valid value for the “@ypad@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCellRendererYpad :: (IsCellRenderer o) => Word32 -> IO (GValueConstruct o)
constructCellRendererYpad val = B.Properties.constructObjectPropertyUInt32 "ypad" val

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

#if 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, *)])
#endif

#if 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 ENABLE_OVERLOADING
data CellRendererEditingCanceledSignalInfo
instance SignalInfo CellRendererEditingCanceledSignalInfo where
    type HaskellCallbackType CellRendererEditingCanceledSignalInfo = CellRendererEditingCanceledCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_CellRendererEditingCanceledCallback cb
        cb'' <- mk_CellRendererEditingCanceledCallback cb'
        connectSignalFunPtr obj "editing-canceled" cb'' connectMode

data CellRendererEditingStartedSignalInfo
instance SignalInfo CellRendererEditingStartedSignalInfo where
    type HaskellCallbackType CellRendererEditingStartedSignalInfo = CellRendererEditingStartedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_CellRendererEditingStartedCallback cb
        cb'' <- mk_CellRendererEditingStartedCallback cb'
        connectSignalFunPtr obj "editing-started" cb'' connectMode

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

#endif

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

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

{- |
Passes an activate event to the cell renderer for possible processing.
Some cell renderers may use events; for example, '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 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> Gdk.Event.Event
    {- ^ /@event@/: a '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 'GI.Gtk.Objects.TreeView.TreeView', a string representation of '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:__ 'True' if the event was consumed\/handled -}
cellRendererActivate cell event widget path backgroundArea cellArea flags = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    event' <- unsafeManagedPtrGetPtr event
    widget' <- unsafeManagedPtrCastPtr widget
    path' <- textToCString path
    backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea
    cellArea' <- unsafeManagedPtrGetPtr cellArea
    let flags' = gflagsToWord flags
    result <- gtk_cell_renderer_activate cell' event' widget' path' backgroundArea' cellArea' flags'
    let result' = (/= 0) result
    touchManagedPtr cell
    touchManagedPtr event
    touchManagedPtr widget
    touchManagedPtr backgroundArea
    touchManagedPtr cellArea
    freeMem path'
    return result'

#if 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.MethodInfo CellRendererActivateMethodInfo a signature where
    overloadedMethod _ = cellRendererActivate

#endif

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

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

{- |
Gets the aligned area used by /@cell@/ inside /@cellArea@/. Used for finding
the appropriate edit and focus rectangle.

/Since: 3.0/
-}
cellRendererGetAlignedArea ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -}
    -> b
    {- ^ /@widget@/: the '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 cell widget flags cellArea = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    widget' <- unsafeManagedPtrCastPtr widget
    let flags' = gflagsToWord flags
    cellArea' <- unsafeManagedPtrGetPtr cellArea
    alignedArea <- 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 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.MethodInfo CellRendererGetAlignedAreaMethodInfo a signature where
    overloadedMethod _ = cellRendererGetAlignedArea

#endif

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

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

{- |
Fills in /@xalign@/ and /@yalign@/ with the appropriate values of /@cell@/.

/Since: 2.18/
-}
cellRendererGetAlignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> m ((Float, Float))
cellRendererGetAlignment cell = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    xalign <- allocMem :: IO (Ptr CFloat)
    yalign <- allocMem :: IO (Ptr CFloat)
    gtk_cell_renderer_get_alignment cell' xalign yalign
    xalign' <- peek xalign
    let xalign'' = realToFrac xalign'
    yalign' <- peek yalign
    let yalign'' = realToFrac yalign'
    touchManagedPtr cell
    freeMem xalign
    freeMem yalign
    return (xalign'', yalign'')

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

#endif

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

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

{- |
Fills in /@width@/ and /@height@/ with the appropriate size of /@cell@/.
-}
cellRendererGetFixedSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> m ((Int32, Int32))
cellRendererGetFixedSize cell = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr 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 ENABLE_OVERLOADING
data CellRendererGetFixedSizeMethodInfo
instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererGetFixedSizeMethodInfo a signature where
    overloadedMethod _ = cellRendererGetFixedSize

#endif

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

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

{- |
Fills in /@xpad@/ and /@ypad@/ with the appropriate values of /@cell@/.

/Since: 2.18/
-}
cellRendererGetPadding ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> m ((Int32, Int32))
cellRendererGetPadding cell = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr 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 ENABLE_OVERLOADING
data CellRendererGetPaddingMethodInfo
instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererGetPaddingMethodInfo a signature where
    overloadedMethod _ = cellRendererGetPadding

#endif

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

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

{- |
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 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -}
    -> b
    {- ^ /@widget@/: the 'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to -}
    -> m ((Int32, Int32))
cellRendererGetPreferredHeight cell widget = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr 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 ENABLE_OVERLOADING
data CellRendererGetPreferredHeightMethodInfo
instance (signature ~ (b -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetPreferredHeightMethodInfo a signature where
    overloadedMethod _ = cellRendererGetPreferredHeight

#endif

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

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

{- |
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 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -}
    -> b
    {- ^ /@widget@/: the 'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to -}
    -> Int32
    {- ^ /@width@/: the size which is available for allocation -}
    -> m ((Int32, Int32))
cellRendererGetPreferredHeightForWidth cell widget width = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr 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 ENABLE_OVERLOADING
data CellRendererGetPreferredHeightForWidthMethodInfo
instance (signature ~ (b -> Int32 -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetPreferredHeightForWidthMethodInfo a signature where
    overloadedMethod _ = cellRendererGetPreferredHeightForWidth

#endif

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

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

{- |
Retrieves the minimum and natural size of a cell taking
into account the widget’s preference for height-for-width management.

/Since: 3.0/
-}
cellRendererGetPreferredSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -}
    -> b
    {- ^ /@widget@/: the 'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to -}
    -> m ((Gtk.Requisition.Requisition, Gtk.Requisition.Requisition))
cellRendererGetPreferredSize cell widget = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    widget' <- unsafeManagedPtrCastPtr widget
    minimumSize <- callocBoxedBytes 8 :: IO (Ptr Gtk.Requisition.Requisition)
    naturalSize <- 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 ENABLE_OVERLOADING
data CellRendererGetPreferredSizeMethodInfo
instance (signature ~ (b -> m ((Gtk.Requisition.Requisition, Gtk.Requisition.Requisition))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetPreferredSizeMethodInfo a signature where
    overloadedMethod _ = cellRendererGetPreferredSize

#endif

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

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

{- |
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 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -}
    -> b
    {- ^ /@widget@/: the 'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to -}
    -> m ((Int32, Int32))
cellRendererGetPreferredWidth cell widget = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr 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 ENABLE_OVERLOADING
data CellRendererGetPreferredWidthMethodInfo
instance (signature ~ (b -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetPreferredWidthMethodInfo a signature where
    overloadedMethod _ = cellRendererGetPreferredWidth

#endif

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

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

{- |
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 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -}
    -> b
    {- ^ /@widget@/: the 'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to -}
    -> Int32
    {- ^ /@height@/: the size which is available for allocation -}
    -> m ((Int32, Int32))
cellRendererGetPreferredWidthForHeight cell widget height = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr 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 ENABLE_OVERLOADING
data CellRendererGetPreferredWidthForHeightMethodInfo
instance (signature ~ (b -> Int32 -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetPreferredWidthForHeightMethodInfo a signature where
    overloadedMethod _ = cellRendererGetPreferredWidthForHeight

#endif

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

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

{- |
Gets whether the cell renderer prefers a height-for-width layout
or a width-for-height layout.

/Since: 3.0/
-}
cellRendererGetRequestMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer'    instance -}
    -> m Gtk.Enums.SizeRequestMode
    {- ^ __Returns:__ The 'GI.Gtk.Enums.SizeRequestMode' preferred by this renderer. -}
cellRendererGetRequestMode cell = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    result <- gtk_cell_renderer_get_request_mode cell'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr cell
    return result'

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

#endif

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

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

{- |
Returns the cell renderer’s sensitivity.

/Since: 2.18/
-}
cellRendererGetSensitive ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the cell renderer is sensitive -}
cellRendererGetSensitive cell = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    result <- gtk_cell_renderer_get_sensitive cell'
    let result' = (/= 0) result
    touchManagedPtr cell
    return result'

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

#endif

-- method CellRenderer::get_size
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), 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, transfer = TransferNothing},Arg {argCName = "cell_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), 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, transfer = TransferNothing},Arg {argCName = "x_offset", argType = TBasicType TInt, 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, transfer = TransferEverything},Arg {argCName = "y_offset", argType = TBasicType TInt, 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, transfer = TransferEverything},Arg {argCName = "width", argType = TBasicType TInt, 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, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, 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, 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 '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 '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 'Nothing' -}
    -> m ((Int32, Int32, Int32, Int32))
cellRendererGetSize cell widget cellArea = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    widget' <- unsafeManagedPtrCastPtr widget
    maybeCellArea <- case cellArea of
        Nothing -> return nullPtr
        Just jCellArea -> do
            jCellArea' <- unsafeManagedPtrGetPtr 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 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.MethodInfo CellRendererGetSizeMethodInfo a signature where
    overloadedMethod _ = cellRendererGetSize

#endif

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

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

{- |
Translates the cell renderer state to 'GI.Gtk.Flags.StateFlags',
based on the cell renderer and widget sensitivity, and
the given 'GI.Gtk.Flags.CellRendererState'.

/Since: 3.0/
-}
cellRendererGetState ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer', or 'Nothing' -}
    -> Maybe (b)
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget', or 'Nothing' -}
    -> [Gtk.Flags.CellRendererState]
    {- ^ /@cellState@/: cell renderer state -}
    -> m [Gtk.Flags.StateFlags]
    {- ^ __Returns:__ the widget state flags applying to /@cell@/ -}
cellRendererGetState cell widget cellState = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    maybeWidget <- case widget of
        Nothing -> return nullPtr
        Just jWidget -> do
            jWidget' <- unsafeManagedPtrCastPtr jWidget
            return jWidget'
    let cellState' = gflagsToWord cellState
    result <- gtk_cell_renderer_get_state cell' maybeWidget cellState'
    let result' = wordToGFlags result
    touchManagedPtr cell
    whenJust widget touchManagedPtr
    return result'

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

#endif

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

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

{- |
Returns the cell renderer’s visibility.

/Since: 2.18/
-}
cellRendererGetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the cell renderer is visible -}
cellRendererGetVisible cell = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    result <- gtk_cell_renderer_get_visible cell'
    let result' = (/= 0) result
    touchManagedPtr cell
    return result'

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

#endif

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

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

{- |
Checks whether the cell renderer can do something when activated.

/Since: 3.0/
-}
cellRendererIsActivatable ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the cell renderer can do anything when activated -}
cellRendererIsActivatable cell = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    result <- gtk_cell_renderer_is_activatable cell'
    let result' = (/= 0) result
    touchManagedPtr cell
    return result'

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

#endif

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

foreign import ccall "gtk_cell_renderer_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 '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 '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 '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 cell cr widget backgroundArea cellArea flags = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    cr' <- unsafeManagedPtrGetPtr cr
    widget' <- unsafeManagedPtrCastPtr widget
    backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea
    cellArea' <- unsafeManagedPtrGetPtr cellArea
    let flags' = gflagsToWord flags
    gtk_cell_renderer_render cell' cr' widget' backgroundArea' cellArea' flags'
    touchManagedPtr cell
    touchManagedPtr cr
    touchManagedPtr widget
    touchManagedPtr backgroundArea
    touchManagedPtr cellArea
    return ()

#if 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.MethodInfo CellRendererRenderMethodInfo a signature where
    overloadedMethod _ = cellRendererRender

#endif

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

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

{- |
Sets the renderer’s alignment within its available space.

/Since: 2.18/
-}
cellRendererSetAlignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: A '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 cell xalign yalign = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    let xalign' = realToFrac xalign
    let yalign' = realToFrac yalign
    gtk_cell_renderer_set_alignment cell' xalign' yalign'
    touchManagedPtr cell
    return ()

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

#endif

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

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

{- |
Sets the renderer size to be explicit, independent of the properties set.
-}
cellRendererSetFixedSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: A '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 cell width height = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    gtk_cell_renderer_set_fixed_size cell' width height
    touchManagedPtr cell
    return ()

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

#endif

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

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

{- |
Sets the renderer’s padding.

/Since: 2.18/
-}
cellRendererSetPadding ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: A '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 cell xpad ypad = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    gtk_cell_renderer_set_padding cell' xpad ypad
    touchManagedPtr cell
    return ()

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

#endif

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

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

{- |
Sets the cell renderer’s sensitivity.

/Since: 2.18/
-}
cellRendererSetSensitive ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> Bool
    {- ^ /@sensitive@/: the sensitivity of the cell -}
    -> m ()
cellRendererSetSensitive cell sensitive = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    let sensitive' = (fromIntegral . fromEnum) sensitive
    gtk_cell_renderer_set_sensitive cell' sensitive'
    touchManagedPtr cell
    return ()

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

#endif

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

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

{- |
Sets the cell renderer’s visibility.

/Since: 2.18/
-}
cellRendererSetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> Bool
    {- ^ /@visible@/: the visibility of the cell -}
    -> m ()
cellRendererSetVisible cell visible = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    let visible' = (fromIntegral . fromEnum) visible
    gtk_cell_renderer_set_visible cell' visible'
    touchManagedPtr cell
    return ()

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

#endif

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

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

{- |
Starts editing the contents of this /@cell@/, through a new 'GI.Gtk.Interfaces.CellEditable.CellEditable'
widget created by the 'GI.Gtk.Structs.CellRendererClass.CellRendererClass'.@/start_editing/@ virtual function.
-}
cellRendererStartEditing ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> Maybe (Gdk.Event.Event)
    {- ^ /@event@/: a '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 'GI.Gtk.Objects.TreeView.TreeView', a string representation of '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 'GI.Gtk.Interfaces.CellEditable.CellEditable' for editing this
  /@cell@/, or 'Nothing' if editing is not possible -}
cellRendererStartEditing cell event widget path backgroundArea cellArea flags = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    maybeEvent <- case event of
        Nothing -> return nullPtr
        Just jEvent -> do
            jEvent' <- unsafeManagedPtrGetPtr jEvent
            return jEvent'
    widget' <- unsafeManagedPtrCastPtr widget
    path' <- textToCString path
    backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea
    cellArea' <- unsafeManagedPtrGetPtr cellArea
    let flags' = gflagsToWord flags
    result <- gtk_cell_renderer_start_editing cell' maybeEvent widget' path' backgroundArea' cellArea' flags'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gtk.CellEditable.CellEditable) result'
        return result''
    touchManagedPtr cell
    whenJust event touchManagedPtr
    touchManagedPtr widget
    touchManagedPtr backgroundArea
    touchManagedPtr cellArea
    freeMem path'
    return maybeResult

#if 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.MethodInfo CellRendererStartEditingMethodInfo a signature where
    overloadedMethod _ = cellRendererStartEditing

#endif

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

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

{- |
Informs the cell renderer that the editing is stopped.
If /@canceled@/ is 'True', the cell renderer will emit the
'GI.Gtk.Objects.CellRenderer.CellRenderer'::@/editing-canceled/@ signal.

This function should be called by cell renderer implementations
in response to the 'GI.Gtk.Interfaces.CellEditable.CellEditable'::@/editing-done/@ signal of
'GI.Gtk.Interfaces.CellEditable.CellEditable'.

/Since: 2.6/
-}
cellRendererStopEditing ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -}
    -> Bool
    {- ^ /@canceled@/: 'True' if the editing has been canceled -}
    -> m ()
cellRendererStopEditing cell canceled = liftIO $ do
    cell' <- unsafeManagedPtrCastPtr cell
    let canceled' = (fromIntegral . fromEnum) canceled
    gtk_cell_renderer_stop_editing cell' canceled'
    touchManagedPtr cell
    return ()

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

#endif