{-# LANGUAGE TypeApplications #-}


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

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

module GI.Gtk.Objects.CellRenderer
    ( 

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


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveCellRendererMethod               ,
#endif


-- ** activate #method:activate#

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


-- ** getAlignedArea #method:getAlignedArea#

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


-- ** getAlignment #method:getAlignment#

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


-- ** getFixedSize #method:getFixedSize#

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


-- ** getPadding #method:getPadding#

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


-- ** getPreferredHeight #method:getPreferredHeight#

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


-- ** getPreferredHeightForWidth #method:getPreferredHeightForWidth#

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


-- ** getPreferredSize #method:getPreferredSize#

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


-- ** getPreferredWidth #method:getPreferredWidth#

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


-- ** getPreferredWidthForHeight #method:getPreferredWidthForHeight#

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


-- ** getRequestMode #method:getRequestMode#

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


-- ** getSensitive #method:getSensitive#

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


-- ** getSize #method:getSize#

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


-- ** getState #method:getState#

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


-- ** getVisible #method:getVisible#

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


-- ** isActivatable #method:isActivatable#

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


-- ** render #method:render#

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


-- ** setAlignment #method:setAlignment#

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


-- ** setFixedSize #method:setFixedSize#

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


-- ** setPadding #method:setPadding#

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


-- ** setSensitive #method:setSensitive#

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


-- ** setVisible #method:setVisible#

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


-- ** startEditing #method:startEditing#

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


-- ** stopEditing #method:stopEditing#

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




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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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




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

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


-- ** editingStarted #signal:editingStarted#

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




    ) where

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

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

import qualified 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 (SP.ManagedPtr CellRenderer)
    deriving (CellRenderer -> CellRenderer -> Bool
(CellRenderer -> CellRenderer -> Bool)
-> (CellRenderer -> CellRenderer -> Bool) -> Eq CellRenderer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CellRenderer -> CellRenderer -> Bool
$c/= :: CellRenderer -> CellRenderer -> Bool
== :: CellRenderer -> CellRenderer -> Bool
$c== :: CellRenderer -> CellRenderer -> Bool
Eq)

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

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

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

instance B.Types.GObject CellRenderer

-- | Convert 'CellRenderer' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue CellRenderer where
    toGValue :: CellRenderer -> IO GValue
toGValue CellRenderer
o = do
        GType
gtype <- IO GType
c_gtk_cell_renderer_get_type
        CellRenderer -> (Ptr CellRenderer -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr CellRenderer
o (GType
-> (GValue -> Ptr CellRenderer -> IO ())
-> Ptr CellRenderer
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr CellRenderer -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO CellRenderer
fromGValue GValue
gv = do
        Ptr CellRenderer
ptr <- GValue -> IO (Ptr CellRenderer)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr CellRenderer)
        (ManagedPtr CellRenderer -> CellRenderer)
-> Ptr CellRenderer -> IO CellRenderer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr CellRenderer -> CellRenderer
CellRenderer Ptr CellRenderer
ptr
        
    

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveCellRendererMethod (t :: Symbol) (o :: *) :: * where
    ResolveCellRendererMethod "activate" o = CellRendererActivateMethodInfo
    ResolveCellRendererMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCellRendererMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCellRendererMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCellRendererMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCellRendererMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveCellRendererMethod "isActivatable" o = CellRendererIsActivatableMethodInfo
    ResolveCellRendererMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCellRendererMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCellRendererMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCellRendererMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCellRendererMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCellRendererMethod "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 @info
#else
    fromLabel _ = O.overloadedMethod @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 :: Maybe (IO ())
noCellRendererEditingCanceledCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

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


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


-- | Connect a signal handler for the [editingCanceled](#signal:editingCanceled) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' cellRenderer #editingCanceled callback
-- @
-- 
-- 
onCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingCanceledCallback -> m SignalHandlerId
onCellRendererEditingCanceled :: a -> IO () -> m SignalHandlerId
onCellRendererEditingCanceled a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CellRendererEditingCanceledCallback
cb' = IO () -> C_CellRendererEditingCanceledCallback
wrap_CellRendererEditingCanceledCallback IO ()
cb
    FunPtr C_CellRendererEditingCanceledCallback
cb'' <- C_CellRendererEditingCanceledCallback
-> IO (FunPtr C_CellRendererEditingCanceledCallback)
mk_CellRendererEditingCanceledCallback C_CellRendererEditingCanceledCallback
cb'
    a
-> Text
-> FunPtr C_CellRendererEditingCanceledCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"editing-canceled" FunPtr C_CellRendererEditingCanceledCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [editingCanceled](#signal:editingCanceled) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' cellRenderer #editingCanceled callback
-- @
-- 
-- 
afterCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingCanceledCallback -> m SignalHandlerId
afterCellRendererEditingCanceled :: a -> IO () -> m SignalHandlerId
afterCellRendererEditingCanceled a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CellRendererEditingCanceledCallback
cb' = IO () -> C_CellRendererEditingCanceledCallback
wrap_CellRendererEditingCanceledCallback IO ()
cb
    FunPtr C_CellRendererEditingCanceledCallback
cb'' <- C_CellRendererEditingCanceledCallback
-> IO (FunPtr C_CellRendererEditingCanceledCallback)
mk_CellRendererEditingCanceledCallback C_CellRendererEditingCanceledCallback
cb'
    a
-> Text
-> FunPtr C_CellRendererEditingCanceledCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"editing-canceled" FunPtr C_CellRendererEditingCanceledCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


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

#endif

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

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

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

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

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


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


-- | Connect a signal handler for the [editingStarted](#signal:editingStarted) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' cellRenderer #editingStarted callback
-- @
-- 
-- 
onCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingStartedCallback -> m SignalHandlerId
onCellRendererEditingStarted :: a -> CellRendererEditingStartedCallback -> m SignalHandlerId
onCellRendererEditingStarted a
obj CellRendererEditingStartedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CellRendererEditingStartedCallback
cb' = CellRendererEditingStartedCallback
-> C_CellRendererEditingStartedCallback
wrap_CellRendererEditingStartedCallback CellRendererEditingStartedCallback
cb
    FunPtr C_CellRendererEditingStartedCallback
cb'' <- C_CellRendererEditingStartedCallback
-> IO (FunPtr C_CellRendererEditingStartedCallback)
mk_CellRendererEditingStartedCallback C_CellRendererEditingStartedCallback
cb'
    a
-> Text
-> FunPtr C_CellRendererEditingStartedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"editing-started" FunPtr C_CellRendererEditingStartedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [editingStarted](#signal:editingStarted) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' cellRenderer #editingStarted callback
-- @
-- 
-- 
afterCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingStartedCallback -> m SignalHandlerId
afterCellRendererEditingStarted :: a -> CellRendererEditingStartedCallback -> m SignalHandlerId
afterCellRendererEditingStarted a
obj CellRendererEditingStartedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CellRendererEditingStartedCallback
cb' = CellRendererEditingStartedCallback
-> C_CellRendererEditingStartedCallback
wrap_CellRendererEditingStartedCallback CellRendererEditingStartedCallback
cb
    FunPtr C_CellRendererEditingStartedCallback
cb'' <- C_CellRendererEditingStartedCallback
-> IO (FunPtr C_CellRendererEditingStartedCallback)
mk_CellRendererEditingStartedCallback C_CellRendererEditingStartedCallback
cb'
    a
-> Text
-> FunPtr C_CellRendererEditingStartedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"editing-started" FunPtr C_CellRendererEditingStartedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


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

#endif

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

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

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

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

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

-- VVV Prop "cell-background-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 :: o -> m (Maybe Color)
getCellRendererCellBackgroundGdk o
obj = IO (Maybe Color) -> m (Maybe Color)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Color) -> m (Maybe Color))
-> IO (Maybe Color) -> m (Maybe Color)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Color -> Color) -> IO (Maybe Color)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"cell-background-gdk" ManagedPtr Color -> Color
Gdk.Color.Color

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

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

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

#if defined(ENABLE_OVERLOADING)
data CellRendererCellBackgroundGdkPropertyInfo
instance AttrInfo CellRendererCellBackgroundGdkPropertyInfo where
    type AttrAllowedOps CellRendererCellBackgroundGdkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = IsCellRenderer
    type AttrSetTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = (~) Gdk.Color.Color
    type AttrTransferTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = (~) Gdk.Color.Color
    type AttrTransferType CellRendererCellBackgroundGdkPropertyInfo = Gdk.Color.Color
    type AttrGetType CellRendererCellBackgroundGdkPropertyInfo = (Maybe Gdk.Color.Color)
    type AttrLabel CellRendererCellBackgroundGdkPropertyInfo = "cell-background-gdk"
    type AttrOrigin CellRendererCellBackgroundGdkPropertyInfo = CellRenderer
    attrGet = getCellRendererCellBackgroundGdk
    attrSet = setCellRendererCellBackgroundGdk
    attrTransfer _ v = do
        return v
    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 :: o -> m (Maybe RGBA)
getCellRendererCellBackgroundRgba o
obj = IO (Maybe RGBA) -> m (Maybe RGBA)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe RGBA) -> m (Maybe RGBA))
-> IO (Maybe RGBA) -> m (Maybe RGBA)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr RGBA -> RGBA) -> IO (Maybe RGBA)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"cell-background-rgba" ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- VVV Prop "is-expanded"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (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 :: o -> m Bool
getCellRendererIsExpanded o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"is-expanded"

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

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

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

-- VVV Prop "is-expander"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (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 :: o -> m Bool
getCellRendererIsExpander o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"is-expander"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList CellRenderer
type instance O.AttributeList CellRenderer = CellRendererAttributeList
type CellRendererAttributeList = ('[ '("cellBackground", CellRendererCellBackgroundPropertyInfo), '("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 defined(ENABLE_OVERLOADING)
cellRendererCellBackground :: AttrLabelProxy "cellBackground"
cellRendererCellBackground = AttrLabelProxy

cellRendererCellBackgroundGdk :: AttrLabelProxy "cellBackgroundGdk"
cellRendererCellBackgroundGdk = AttrLabelProxy

cellRendererCellBackgroundRgba :: AttrLabelProxy "cellBackgroundRgba"
cellRendererCellBackgroundRgba = AttrLabelProxy

cellRendererCellBackgroundSet :: AttrLabelProxy "cellBackgroundSet"
cellRendererCellBackgroundSet = AttrLabelProxy

cellRendererEditing :: AttrLabelProxy "editing"
cellRendererEditing = AttrLabelProxy

cellRendererHeight :: AttrLabelProxy "height"
cellRendererHeight = AttrLabelProxy

cellRendererIsExpanded :: AttrLabelProxy "isExpanded"
cellRendererIsExpanded = AttrLabelProxy

cellRendererIsExpander :: AttrLabelProxy "isExpander"
cellRendererIsExpander = AttrLabelProxy

cellRendererMode :: AttrLabelProxy "mode"
cellRendererMode = AttrLabelProxy

cellRendererSensitive :: AttrLabelProxy "sensitive"
cellRendererSensitive = AttrLabelProxy

cellRendererVisible :: AttrLabelProxy "visible"
cellRendererVisible = AttrLabelProxy

cellRendererWidth :: AttrLabelProxy "width"
cellRendererWidth = AttrLabelProxy

cellRendererXalign :: AttrLabelProxy "xalign"
cellRendererXalign = AttrLabelProxy

cellRendererXpad :: AttrLabelProxy "xpad"
cellRendererXpad = AttrLabelProxy

cellRendererYalign :: AttrLabelProxy "yalign"
cellRendererYalign = AttrLabelProxy

cellRendererYpad :: AttrLabelProxy "ypad"
cellRendererYpad = AttrLabelProxy

#endif

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

#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
data CellRendererActivateMethodInfo
instance (signature ~ (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 t'GI.Gtk.Objects.CellRenderer.CellRenderer' instance
    -> b
    -- ^ /@widget@/: the t'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to
    -> [Gtk.Flags.CellRendererState]
    -- ^ /@flags@/: render flags
    -> Gdk.Rectangle.Rectangle
    -- ^ /@cellArea@/: cell area which would be passed to 'GI.Gtk.Objects.CellRenderer.cellRendererRender'
    -> m (Gdk.Rectangle.Rectangle)
cellRendererGetAlignedArea :: a -> b -> [CellRendererState] -> Rectangle -> m Rectangle
cellRendererGetAlignedArea a
cell b
widget [CellRendererState]
flags Rectangle
cellArea = IO Rectangle -> m Rectangle
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rectangle -> m Rectangle) -> IO Rectangle -> m Rectangle
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    let flags' :: CUInt
flags' = [CellRendererState] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [CellRendererState]
flags
    Ptr Rectangle
cellArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
cellArea
    Ptr Rectangle
alignedArea <- Int -> IO (Ptr Rectangle)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Gdk.Rectangle.Rectangle)
    Ptr CellRenderer
-> Ptr Widget -> CUInt -> Ptr Rectangle -> Ptr Rectangle -> IO ()
gtk_cell_renderer_get_aligned_area Ptr CellRenderer
cell' Ptr Widget
widget' CUInt
flags' Ptr Rectangle
cellArea' Ptr Rectangle
alignedArea
    Rectangle
alignedArea' <- ((ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> IO Rectangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rectangle -> Rectangle
Gdk.Rectangle.Rectangle) Ptr Rectangle
alignedArea
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
cellArea
    Rectangle -> IO Rectangle
forall (m :: * -> *) a. Monad m => a -> m a
return Rectangle
alignedArea'

#if defined(ENABLE_OVERLOADING)
data CellRendererGetAlignedAreaMethodInfo
instance (signature ~ (b -> [Gtk.Flags.CellRendererState] -> Gdk.Rectangle.Rectangle -> m (Gdk.Rectangle.Rectangle)), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m ((Float, Float))
cellRendererGetAlignment :: a -> m (Float, Float)
cellRendererGetAlignment a
cell = IO (Float, Float) -> m (Float, Float)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr CFloat
xalign <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
yalign <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CellRenderer -> Ptr CFloat -> Ptr CFloat -> IO ()
gtk_cell_renderer_get_alignment Ptr CellRenderer
cell' Ptr CFloat
xalign Ptr CFloat
yalign
    CFloat
xalign' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
xalign
    let xalign'' :: Float
xalign'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
xalign'
    CFloat
yalign' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
yalign
    let yalign'' :: Float
yalign'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
yalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
xalign
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
yalign
    (Float, Float) -> IO (Float, Float)
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
xalign'', Float
yalign'')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetAlignmentMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m, IsCellRenderer a) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m ((Int32, Int32))
cellRendererGetFixedSize :: a -> m (Int32, Int32)
cellRendererGetFixedSize a
cell = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Int32
width <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
height <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_cell_renderer_get_fixed_size Ptr CellRenderer
cell' Ptr Int32
width Ptr Int32
height
    Int32
width' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
width
    Int32
height' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
height
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
width
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
height
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
width', Int32
height')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetFixedSizeMethodInfo
instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsCellRenderer a) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m ((Int32, Int32))
cellRendererGetPadding :: a -> m (Int32, Int32)
cellRendererGetPadding a
cell = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Int32
xpad <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
ypad <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_cell_renderer_get_padding Ptr CellRenderer
cell' Ptr Int32
xpad Ptr Int32
ypad
    Int32
xpad' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
xpad
    Int32
ypad' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
ypad
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
xpad
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
ypad
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
xpad', Int32
ypad')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetPaddingMethodInfo
instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsCellRenderer a) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer' instance
    -> b
    -- ^ /@widget@/: the t'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to
    -> m ((Int32, Int32))
cellRendererGetPreferredHeight :: a -> b -> m (Int32, Int32)
cellRendererGetPreferredHeight a
cell b
widget = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Int32
minimumSize <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
naturalSize <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer -> Ptr Widget -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_cell_renderer_get_preferred_height Ptr CellRenderer
cell' Ptr Widget
widget' Ptr Int32
minimumSize Ptr Int32
naturalSize
    Int32
minimumSize' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
minimumSize
    Int32
naturalSize' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
naturalSize
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
minimumSize
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
naturalSize
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
minimumSize', Int32
naturalSize')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetPreferredHeightMethodInfo
instance (signature ~ (b -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer' instance
    -> b
    -- ^ /@widget@/: the t'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to
    -> Int32
    -- ^ /@width@/: the size which is available for allocation
    -> m ((Int32, Int32))
cellRendererGetPreferredHeightForWidth :: a -> b -> Int32 -> m (Int32, Int32)
cellRendererGetPreferredHeightForWidth a
cell b
widget Int32
width = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Int32
minimumHeight <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
naturalHeight <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer
-> Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_cell_renderer_get_preferred_height_for_width Ptr CellRenderer
cell' Ptr Widget
widget' Int32
width Ptr Int32
minimumHeight Ptr Int32
naturalHeight
    Int32
minimumHeight' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
minimumHeight
    Int32
naturalHeight' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
naturalHeight
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
minimumHeight
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
naturalHeight
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
minimumHeight', Int32
naturalHeight')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetPreferredHeightForWidthMethodInfo
instance (signature ~ (b -> Int32 -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer' instance
    -> b
    -- ^ /@widget@/: the t'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to
    -> m ((Gtk.Requisition.Requisition, Gtk.Requisition.Requisition))
cellRendererGetPreferredSize :: a -> b -> m (Requisition, Requisition)
cellRendererGetPreferredSize a
cell b
widget = IO (Requisition, Requisition) -> m (Requisition, Requisition)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Requisition, Requisition) -> m (Requisition, Requisition))
-> IO (Requisition, Requisition) -> m (Requisition, Requisition)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Requisition
minimumSize <- Int -> IO (Ptr Requisition)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
8 :: IO (Ptr Gtk.Requisition.Requisition)
    Ptr Requisition
naturalSize <- Int -> IO (Ptr Requisition)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
8 :: IO (Ptr Gtk.Requisition.Requisition)
    Ptr CellRenderer
-> Ptr Widget -> Ptr Requisition -> Ptr Requisition -> IO ()
gtk_cell_renderer_get_preferred_size Ptr CellRenderer
cell' Ptr Widget
widget' Ptr Requisition
minimumSize Ptr Requisition
naturalSize
    Requisition
minimumSize' <- ((ManagedPtr Requisition -> Requisition)
-> Ptr Requisition -> IO Requisition
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Requisition -> Requisition
Gtk.Requisition.Requisition) Ptr Requisition
minimumSize
    Requisition
naturalSize' <- ((ManagedPtr Requisition -> Requisition)
-> Ptr Requisition -> IO Requisition
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Requisition -> Requisition
Gtk.Requisition.Requisition) Ptr Requisition
naturalSize
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    (Requisition, Requisition) -> IO (Requisition, Requisition)
forall (m :: * -> *) a. Monad m => a -> m a
return (Requisition
minimumSize', Requisition
naturalSize')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetPreferredSizeMethodInfo
instance (signature ~ (b -> m ((Gtk.Requisition.Requisition, Gtk.Requisition.Requisition))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer' instance
    -> b
    -- ^ /@widget@/: the t'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to
    -> m ((Int32, Int32))
cellRendererGetPreferredWidth :: a -> b -> m (Int32, Int32)
cellRendererGetPreferredWidth a
cell b
widget = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Int32
minimumSize <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
naturalSize <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer -> Ptr Widget -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_cell_renderer_get_preferred_width Ptr CellRenderer
cell' Ptr Widget
widget' Ptr Int32
minimumSize Ptr Int32
naturalSize
    Int32
minimumSize' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
minimumSize
    Int32
naturalSize' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
naturalSize
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
minimumSize
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
naturalSize
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
minimumSize', Int32
naturalSize')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetPreferredWidthMethodInfo
instance (signature ~ (b -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer' instance
    -> b
    -- ^ /@widget@/: the t'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to
    -> Int32
    -- ^ /@height@/: the size which is available for allocation
    -> m ((Int32, Int32))
cellRendererGetPreferredWidthForHeight :: a -> b -> Int32 -> m (Int32, Int32)
cellRendererGetPreferredWidthForHeight a
cell b
widget Int32
height = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Int32
minimumWidth <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
naturalWidth <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer
-> Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_cell_renderer_get_preferred_width_for_height Ptr CellRenderer
cell' Ptr Widget
widget' Int32
height Ptr Int32
minimumWidth Ptr Int32
naturalWidth
    Int32
minimumWidth' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
minimumWidth
    Int32
naturalWidth' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
naturalWidth
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
minimumWidth
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
naturalWidth
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
minimumWidth', Int32
naturalWidth')

#if defined(ENABLE_OVERLOADING)
data CellRendererGetPreferredWidthForHeightMethodInfo
instance (signature ~ (b -> Int32 -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'    instance
    -> m Gtk.Enums.SizeRequestMode
    -- ^ __Returns:__ The t'GI.Gtk.Enums.SizeRequestMode' preferred by this renderer.
cellRendererGetRequestMode :: a -> m SizeRequestMode
cellRendererGetRequestMode a
cell = IO SizeRequestMode -> m SizeRequestMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SizeRequestMode -> m SizeRequestMode)
-> IO SizeRequestMode -> m SizeRequestMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    CUInt
result <- Ptr CellRenderer -> IO CUInt
gtk_cell_renderer_get_request_mode Ptr CellRenderer
cell'
    let result' :: SizeRequestMode
result' = (Int -> SizeRequestMode
forall a. Enum a => Int -> a
toEnum (Int -> SizeRequestMode)
-> (CUInt -> Int) -> CUInt -> SizeRequestMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    SizeRequestMode -> IO SizeRequestMode
forall (m :: * -> *) a. Monad m => a -> m a
return SizeRequestMode
result'

#if defined(ENABLE_OVERLOADING)
data CellRendererGetRequestModeMethodInfo
instance (signature ~ (m Gtk.Enums.SizeRequestMode), MonadIO m, IsCellRenderer a) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the cell renderer is sensitive
cellRendererGetSensitive :: a -> m Bool
cellRendererGetSensitive a
cell = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    CInt
result <- Ptr CellRenderer -> IO CInt
gtk_cell_renderer_get_sensitive Ptr CellRenderer
cell'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CellRendererGetSensitiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCellRenderer a) => O.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 'P.Nothing', fills in the
-- x and y offsets (if set) of the cell relative to this location.
-- 
-- Please note that the values set in /@width@/ and /@height@/, as well as those
-- in /@xOffset@/ and /@yOffset@/ are inclusive of the xpad and ypad properties.
cellRendererGetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> b
    -- ^ /@widget@/: the widget the renderer is rendering to
    -> Maybe (Gdk.Rectangle.Rectangle)
    -- ^ /@cellArea@/: The area a cell will be allocated, or 'P.Nothing'
    -> m ((Int32, Int32, Int32, Int32))
cellRendererGetSize :: a -> b -> Maybe Rectangle -> m (Int32, Int32, Int32, Int32)
cellRendererGetSize a
cell b
widget Maybe Rectangle
cellArea = IO (Int32, Int32, Int32, Int32) -> m (Int32, Int32, Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32, Int32, Int32) -> m (Int32, Int32, Int32, Int32))
-> IO (Int32, Int32, Int32, Int32)
-> m (Int32, Int32, Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Rectangle
maybeCellArea <- case Maybe Rectangle
cellArea of
        Maybe Rectangle
Nothing -> Ptr Rectangle -> IO (Ptr Rectangle)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Rectangle
forall a. Ptr a
nullPtr
        Just Rectangle
jCellArea -> do
            Ptr Rectangle
jCellArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
jCellArea
            Ptr Rectangle -> IO (Ptr Rectangle)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Rectangle
jCellArea'
    Ptr Int32
xOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
yOffset <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
width <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
height <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr CellRenderer
-> Ptr Widget
-> Ptr Rectangle
-> Ptr Int32
-> Ptr Int32
-> Ptr Int32
-> Ptr Int32
-> IO ()
gtk_cell_renderer_get_size Ptr CellRenderer
cell' Ptr Widget
widget' Ptr Rectangle
maybeCellArea Ptr Int32
xOffset Ptr Int32
yOffset Ptr Int32
width Ptr Int32
height
    Int32
xOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
xOffset
    Int32
yOffset' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
yOffset
    Int32
width' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
width
    Int32
height' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
height
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Maybe Rectangle -> (Rectangle -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Rectangle
cellArea Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
xOffset
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
yOffset
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
width
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
height
    (Int32, Int32, Int32, Int32) -> IO (Int32, Int32, Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
xOffset', Int32
yOffset', Int32
width', Int32
height')

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

#if defined(ENABLE_OVERLOADING)
data CellRendererGetStateMethodInfo
instance (signature ~ (Maybe (b) -> [Gtk.Flags.CellRendererState] -> m [Gtk.Flags.StateFlags]), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the cell renderer is visible
cellRendererGetVisible :: a -> m Bool
cellRendererGetVisible a
cell = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    CInt
result <- Ptr CellRenderer -> IO CInt
gtk_cell_renderer_get_visible Ptr CellRenderer
cell'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CellRendererGetVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCellRenderer a) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the cell renderer can do anything when activated
cellRendererIsActivatable :: a -> m Bool
cellRendererIsActivatable a
cell = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    CInt
result <- Ptr CellRenderer -> IO CInt
gtk_cell_renderer_is_activatable Ptr CellRenderer
cell'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CellRendererIsActivatableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCellRenderer a) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'. The three
-- passed-in rectangles are areas in /@cr@/. Most renderers will draw within
-- /@cellArea@/; the xalign, yalign, xpad, and ypad fields of the t'GI.Gtk.Objects.CellRenderer.CellRenderer'
-- should be honored with respect to /@cellArea@/. /@backgroundArea@/ includes the
-- blank space around the cell, and also the area containing the tree expander;
-- so the /@backgroundArea@/ rectangles for all cells tile to cover the entire
-- /@window@/.
cellRendererRender ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@cell@/: a t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Cairo.Context.Context
    -- ^ /@cr@/: a cairo context to draw to
    -> b
    -- ^ /@widget@/: the widget owning /@window@/
    -> Gdk.Rectangle.Rectangle
    -- ^ /@backgroundArea@/: entire cell area (including tree expanders and maybe
    --    padding on the sides)
    -> Gdk.Rectangle.Rectangle
    -- ^ /@cellArea@/: area normally rendered by a cell renderer
    -> [Gtk.Flags.CellRendererState]
    -- ^ /@flags@/: flags that affect rendering
    -> m ()
cellRendererRender :: a
-> Context
-> b
-> Rectangle
-> Rectangle
-> [CellRendererState]
-> m ()
cellRendererRender a
cell Context
cr b
widget Rectangle
backgroundArea Rectangle
cellArea [CellRendererState]
flags = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr Context
cr' <- Context -> IO (Ptr Context)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Context
cr
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr Rectangle
backgroundArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
backgroundArea
    Ptr Rectangle
cellArea' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
cellArea
    let flags' :: CUInt
flags' = [CellRendererState] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [CellRendererState]
flags
    Ptr CellRenderer
-> Ptr Context
-> Ptr Widget
-> Ptr Rectangle
-> Ptr Rectangle
-> CUInt
-> IO ()
gtk_cell_renderer_render Ptr CellRenderer
cell' Ptr Context
cr' Ptr Widget
widget' Ptr Rectangle
backgroundArea' Ptr Rectangle
cellArea' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    Context -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Context
cr
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
backgroundArea
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
cellArea
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data 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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Float
    -- ^ /@xalign@/: the x alignment of the cell renderer
    -> Float
    -- ^ /@yalign@/: the y alignment of the cell renderer
    -> m ()
cellRendererSetAlignment :: a -> Float -> Float -> m ()
cellRendererSetAlignment a
cell Float
xalign Float
yalign = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    let xalign' :: CFloat
xalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
xalign
    let yalign' :: CFloat
yalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
yalign
    Ptr CellRenderer -> CFloat -> CFloat -> IO ()
gtk_cell_renderer_set_alignment Ptr CellRenderer
cell' CFloat
xalign' CFloat
yalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererSetAlignmentMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m, IsCellRenderer a) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Int32
    -- ^ /@width@/: the width of the cell renderer, or -1
    -> Int32
    -- ^ /@height@/: the height of the cell renderer, or -1
    -> m ()
cellRendererSetFixedSize :: a -> Int32 -> Int32 -> m ()
cellRendererSetFixedSize a
cell Int32
width Int32
height = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr CellRenderer -> Int32 -> Int32 -> IO ()
gtk_cell_renderer_set_fixed_size Ptr CellRenderer
cell' Int32
width Int32
height
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererSetFixedSizeMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsCellRenderer a) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Int32
    -- ^ /@xpad@/: the x padding of the cell renderer
    -> Int32
    -- ^ /@ypad@/: the y padding of the cell renderer
    -> m ()
cellRendererSetPadding :: a -> Int32 -> Int32 -> m ()
cellRendererSetPadding a
cell Int32
xpad Int32
ypad = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    Ptr CellRenderer -> Int32 -> Int32 -> IO ()
gtk_cell_renderer_set_padding Ptr CellRenderer
cell' Int32
xpad Int32
ypad
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererSetPaddingMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsCellRenderer a) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Bool
    -- ^ /@sensitive@/: the sensitivity of the cell
    -> m ()
cellRendererSetSensitive :: a -> Bool -> m ()
cellRendererSetSensitive a
cell Bool
sensitive = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    let sensitive' :: CInt
sensitive' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
sensitive
    Ptr CellRenderer -> CInt -> IO ()
gtk_cell_renderer_set_sensitive Ptr CellRenderer
cell' CInt
sensitive'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CellRendererSetSensitiveMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsCellRenderer a) => O.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 t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Bool
    -- ^ /@visible@/: the visibility of the cell
    -> m ()
cellRendererSetVisible :: a -> Bool -> m ()
cellRendererSetVisible a
cell Bool
visible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
    Ptr CellRenderer -> CInt -> IO ()
gtk_cell_renderer_set_visible Ptr CellRenderer
cell' CInt
visible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

#if defined(ENABLE_OVERLOADING)
data CellRendererStartEditingMethodInfo
instance (signature ~ (Maybe (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 'P.True', the cell renderer will emit the
-- [editingCanceled]("GI.Gtk.Objects.CellRenderer#g:signal:editingCanceled") signal.
-- 
-- This function should be called by cell renderer implementations
-- in response to the [editingDone]("GI.Gtk.Interfaces.CellEditable#g:signal:editingDone") signal of
-- t'GI.Gtk.Interfaces.CellEditable.CellEditable'.
-- 
-- /Since: 2.6/
cellRendererStopEditing ::
    (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) =>
    a
    -- ^ /@cell@/: A t'GI.Gtk.Objects.CellRenderer.CellRenderer'
    -> Bool
    -- ^ /@canceled@/: 'P.True' if the editing has been canceled
    -> m ()
cellRendererStopEditing :: a -> Bool -> m ()
cellRendererStopEditing a
cell Bool
canceled = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr CellRenderer
cell' <- a -> IO (Ptr CellRenderer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cell
    let canceled' :: CInt
canceled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
canceled
    Ptr CellRenderer -> CInt -> IO ()
gtk_cell_renderer_stop_editing Ptr CellRenderer
cell' CInt
canceled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cell
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

#endif