{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.Gtk.Objects.CellRenderer
    ( 

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


 -- * Methods
-- ** cellRendererActivate
    cellRendererActivate                    ,


-- ** cellRendererGetAlignedArea
    cellRendererGetAlignedArea              ,


-- ** cellRendererGetAlignment
    cellRendererGetAlignment                ,


-- ** cellRendererGetFixedSize
    cellRendererGetFixedSize                ,


-- ** cellRendererGetPadding
    cellRendererGetPadding                  ,


-- ** cellRendererGetPreferredHeight
    cellRendererGetPreferredHeight          ,


-- ** cellRendererGetPreferredHeightForWidth
    cellRendererGetPreferredHeightForWidth  ,


-- ** cellRendererGetPreferredSize
    cellRendererGetPreferredSize            ,


-- ** cellRendererGetPreferredWidth
    cellRendererGetPreferredWidth           ,


-- ** cellRendererGetPreferredWidthForHeight
    cellRendererGetPreferredWidthForHeight  ,


-- ** cellRendererGetRequestMode
    cellRendererGetRequestMode              ,


-- ** cellRendererGetSensitive
    cellRendererGetSensitive                ,


-- ** cellRendererGetSize
    cellRendererGetSize                     ,


-- ** cellRendererGetState
    cellRendererGetState                    ,


-- ** cellRendererGetVisible
    cellRendererGetVisible                  ,


-- ** cellRendererIsActivatable
    cellRendererIsActivatable               ,


-- ** cellRendererRender
    cellRendererRender                      ,


-- ** cellRendererSetAlignment
    cellRendererSetAlignment                ,


-- ** cellRendererSetFixedSize
    cellRendererSetFixedSize                ,


-- ** cellRendererSetPadding
    cellRendererSetPadding                  ,


-- ** cellRendererSetSensitive
    cellRendererSetSensitive                ,


-- ** cellRendererSetVisible
    cellRendererSetVisible                  ,


-- ** cellRendererStartEditing
    cellRendererStartEditing                ,


-- ** cellRendererStopEditing
    cellRendererStopEditing                 ,




 -- * Properties
-- ** CellBackground
    CellRendererCellBackgroundPropertyInfo  ,
    constructCellRendererCellBackground     ,
    setCellRendererCellBackground           ,


-- ** CellBackgroundGdk
    CellRendererCellBackgroundGdkPropertyInfo,
    constructCellRendererCellBackgroundGdk  ,
    getCellRendererCellBackgroundGdk        ,
    setCellRendererCellBackgroundGdk        ,


-- ** CellBackgroundRgba
    CellRendererCellBackgroundRgbaPropertyInfo,
    constructCellRendererCellBackgroundRgba ,
    getCellRendererCellBackgroundRgba       ,
    setCellRendererCellBackgroundRgba       ,


-- ** CellBackgroundSet
    CellRendererCellBackgroundSetPropertyInfo,
    constructCellRendererCellBackgroundSet  ,
    getCellRendererCellBackgroundSet        ,
    setCellRendererCellBackgroundSet        ,


-- ** Editing
    CellRendererEditingPropertyInfo         ,
    getCellRendererEditing                  ,


-- ** Height
    CellRendererHeightPropertyInfo          ,
    constructCellRendererHeight             ,
    getCellRendererHeight                   ,
    setCellRendererHeight                   ,


-- ** IsExpanded
    CellRendererIsExpandedPropertyInfo      ,
    constructCellRendererIsExpanded         ,
    getCellRendererIsExpanded               ,
    setCellRendererIsExpanded               ,


-- ** IsExpander
    CellRendererIsExpanderPropertyInfo      ,
    constructCellRendererIsExpander         ,
    getCellRendererIsExpander               ,
    setCellRendererIsExpander               ,


-- ** Mode
    CellRendererModePropertyInfo            ,
    constructCellRendererMode               ,
    getCellRendererMode                     ,
    setCellRendererMode                     ,


-- ** Sensitive
    CellRendererSensitivePropertyInfo       ,
    constructCellRendererSensitive          ,
    getCellRendererSensitive                ,
    setCellRendererSensitive                ,


-- ** Visible
    CellRendererVisiblePropertyInfo         ,
    constructCellRendererVisible            ,
    getCellRendererVisible                  ,
    setCellRendererVisible                  ,


-- ** Width
    CellRendererWidthPropertyInfo           ,
    constructCellRendererWidth              ,
    getCellRendererWidth                    ,
    setCellRendererWidth                    ,


-- ** Xalign
    CellRendererXalignPropertyInfo          ,
    constructCellRendererXalign             ,
    getCellRendererXalign                   ,
    setCellRendererXalign                   ,


-- ** Xpad
    CellRendererXpadPropertyInfo            ,
    constructCellRendererXpad               ,
    getCellRendererXpad                     ,
    setCellRendererXpad                     ,


-- ** Yalign
    CellRendererYalignPropertyInfo          ,
    constructCellRendererYalign             ,
    getCellRendererYalign                   ,
    setCellRendererYalign                   ,


-- ** Ypad
    CellRendererYpadPropertyInfo            ,
    constructCellRendererYpad               ,
    getCellRendererYpad                     ,
    setCellRendererYpad                     ,




 -- * Signals
-- ** EditingCanceled
    CellRendererEditingCanceledCallback     ,
    CellRendererEditingCanceledCallbackC    ,
    CellRendererEditingCanceledSignalInfo   ,
    afterCellRendererEditingCanceled        ,
    cellRendererEditingCanceledCallbackWrapper,
    cellRendererEditingCanceledClosure      ,
    mkCellRendererEditingCanceledCallback   ,
    noCellRendererEditingCanceledCallback   ,
    onCellRendererEditingCanceled           ,


-- ** EditingStarted
    CellRendererEditingStartedCallback      ,
    CellRendererEditingStartedCallbackC     ,
    CellRendererEditingStartedSignalInfo    ,
    afterCellRendererEditingStarted         ,
    cellRendererEditingStartedCallbackWrapper,
    cellRendererEditingStartedClosure       ,
    mkCellRendererEditingStartedCallback    ,
    noCellRendererEditingStartedCallback    ,
    onCellRendererEditingStarted            ,




    ) where

import Prelude ()
import Data.GI.Base.ShortPrelude

import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map

import GI.Gtk.Types
import GI.Gtk.Callbacks
import qualified GI.GObject as GObject
import qualified GI.Gdk as Gdk
import qualified GI.Cairo as Cairo

newtype CellRenderer = CellRenderer (ForeignPtr CellRenderer)
foreign import ccall "gtk_cell_renderer_get_type"
    c_gtk_cell_renderer_get_type :: IO GType

type instance ParentTypes CellRenderer = CellRendererParentTypes
type CellRendererParentTypes = '[GObject.Object]

instance GObject CellRenderer where
    gobjectIsInitiallyUnowned _ = True
    gobjectType _ = c_gtk_cell_renderer_get_type
    

class GObject o => CellRendererK o
instance (GObject o, IsDescendantOf CellRenderer o) => CellRendererK o

toCellRenderer :: CellRendererK o => o -> IO CellRenderer
toCellRenderer = unsafeCastTo CellRenderer

noCellRenderer :: Maybe CellRenderer
noCellRenderer = Nothing

-- signal CellRenderer::editing-canceled
type CellRendererEditingCanceledCallback =
    IO ()

noCellRendererEditingCanceledCallback :: Maybe CellRendererEditingCanceledCallback
noCellRendererEditingCanceledCallback = Nothing

type CellRendererEditingCanceledCallbackC =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkCellRendererEditingCanceledCallback :: CellRendererEditingCanceledCallbackC -> IO (FunPtr CellRendererEditingCanceledCallbackC)

cellRendererEditingCanceledClosure :: CellRendererEditingCanceledCallback -> IO Closure
cellRendererEditingCanceledClosure cb = newCClosure =<< mkCellRendererEditingCanceledCallback wrapped
    where wrapped = cellRendererEditingCanceledCallbackWrapper cb

cellRendererEditingCanceledCallbackWrapper ::
    CellRendererEditingCanceledCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
cellRendererEditingCanceledCallbackWrapper _cb _ _ = do
    _cb 

onCellRendererEditingCanceled :: (GObject a, MonadIO m) => a -> CellRendererEditingCanceledCallback -> m SignalHandlerId
onCellRendererEditingCanceled obj cb = liftIO $ connectCellRendererEditingCanceled obj cb SignalConnectBefore
afterCellRendererEditingCanceled :: (GObject a, MonadIO m) => a -> CellRendererEditingCanceledCallback -> m SignalHandlerId
afterCellRendererEditingCanceled obj cb = connectCellRendererEditingCanceled obj cb SignalConnectAfter

connectCellRendererEditingCanceled :: (GObject a, MonadIO m) =>
                                      a -> CellRendererEditingCanceledCallback -> SignalConnectMode -> m SignalHandlerId
connectCellRendererEditingCanceled obj cb after = liftIO $ do
    cb' <- mkCellRendererEditingCanceledCallback (cellRendererEditingCanceledCallbackWrapper cb)
    connectSignalFunPtr obj "editing-canceled" cb' after

-- signal CellRenderer::editing-started
type CellRendererEditingStartedCallback =
    CellEditable ->
    T.Text ->
    IO ()

noCellRendererEditingStartedCallback :: Maybe CellRendererEditingStartedCallback
noCellRendererEditingStartedCallback = Nothing

type CellRendererEditingStartedCallbackC =
    Ptr () ->                               -- object
    Ptr CellEditable ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkCellRendererEditingStartedCallback :: CellRendererEditingStartedCallbackC -> IO (FunPtr CellRendererEditingStartedCallbackC)

cellRendererEditingStartedClosure :: CellRendererEditingStartedCallback -> IO Closure
cellRendererEditingStartedClosure cb = newCClosure =<< mkCellRendererEditingStartedCallback wrapped
    where wrapped = cellRendererEditingStartedCallbackWrapper cb

cellRendererEditingStartedCallbackWrapper ::
    CellRendererEditingStartedCallback ->
    Ptr () ->
    Ptr CellEditable ->
    CString ->
    Ptr () ->
    IO ()
cellRendererEditingStartedCallbackWrapper _cb _ editable path _ = do
    editable' <- (newObject CellEditable) editable
    path' <- cstringToText path
    _cb  editable' path'

onCellRendererEditingStarted :: (GObject a, MonadIO m) => a -> CellRendererEditingStartedCallback -> m SignalHandlerId
onCellRendererEditingStarted obj cb = liftIO $ connectCellRendererEditingStarted obj cb SignalConnectBefore
afterCellRendererEditingStarted :: (GObject a, MonadIO m) => a -> CellRendererEditingStartedCallback -> m SignalHandlerId
afterCellRendererEditingStarted obj cb = connectCellRendererEditingStarted obj cb SignalConnectAfter

connectCellRendererEditingStarted :: (GObject a, MonadIO m) =>
                                     a -> CellRendererEditingStartedCallback -> SignalConnectMode -> m SignalHandlerId
connectCellRendererEditingStarted obj cb after = liftIO $ do
    cb' <- mkCellRendererEditingStartedCallback (cellRendererEditingStartedCallbackWrapper cb)
    connectSignalFunPtr obj "editing-started" cb' after

-- VVV Prop "cell-background"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyWritable]

setCellRendererCellBackground :: (MonadIO m, CellRendererK o) => o -> T.Text -> m ()
setCellRendererCellBackground obj val = liftIO $ setObjectPropertyString obj "cell-background" val

constructCellRendererCellBackground :: T.Text -> IO ([Char], GValue)
constructCellRendererCellBackground val = constructObjectPropertyString "cell-background" val

data CellRendererCellBackgroundPropertyInfo
instance AttrInfo CellRendererCellBackgroundPropertyInfo where
    type AttrAllowedOps CellRendererCellBackgroundPropertyInfo = '[ 'AttrSet, 'AttrConstruct]
    type AttrSetTypeConstraint CellRendererCellBackgroundPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CellRendererCellBackgroundPropertyInfo = CellRendererK
    type AttrGetType CellRendererCellBackgroundPropertyInfo = ()
    type AttrLabel CellRendererCellBackgroundPropertyInfo = "CellRenderer::cell-background"
    attrGet _ = undefined
    attrSet _ = setCellRendererCellBackground
    attrConstruct _ = constructCellRendererCellBackground

-- VVV Prop "cell-background-gdk"
   -- Type: TInterface "Gdk" "Color"
   -- Flags: [PropertyReadable,PropertyWritable]

getCellRendererCellBackgroundGdk :: (MonadIO m, CellRendererK o) => o -> m Gdk.Color
getCellRendererCellBackgroundGdk obj = liftIO $ getObjectPropertyBoxed obj "cell-background-gdk" Gdk.Color

setCellRendererCellBackgroundGdk :: (MonadIO m, CellRendererK o) => o -> Gdk.Color -> m ()
setCellRendererCellBackgroundGdk obj val = liftIO $ setObjectPropertyBoxed obj "cell-background-gdk" val

constructCellRendererCellBackgroundGdk :: Gdk.Color -> IO ([Char], GValue)
constructCellRendererCellBackgroundGdk val = constructObjectPropertyBoxed "cell-background-gdk" val

data CellRendererCellBackgroundGdkPropertyInfo
instance AttrInfo CellRendererCellBackgroundGdkPropertyInfo where
    type AttrAllowedOps CellRendererCellBackgroundGdkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = (~) Gdk.Color
    type AttrBaseTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = CellRendererK
    type AttrGetType CellRendererCellBackgroundGdkPropertyInfo = Gdk.Color
    type AttrLabel CellRendererCellBackgroundGdkPropertyInfo = "CellRenderer::cell-background-gdk"
    attrGet _ = getCellRendererCellBackgroundGdk
    attrSet _ = setCellRendererCellBackgroundGdk
    attrConstruct _ = constructCellRendererCellBackgroundGdk

-- VVV Prop "cell-background-rgba"
   -- Type: TInterface "Gdk" "RGBA"
   -- Flags: [PropertyReadable,PropertyWritable]

getCellRendererCellBackgroundRgba :: (MonadIO m, CellRendererK o) => o -> m Gdk.RGBA
getCellRendererCellBackgroundRgba obj = liftIO $ getObjectPropertyBoxed obj "cell-background-rgba" Gdk.RGBA

setCellRendererCellBackgroundRgba :: (MonadIO m, CellRendererK o) => o -> Gdk.RGBA -> m ()
setCellRendererCellBackgroundRgba obj val = liftIO $ setObjectPropertyBoxed obj "cell-background-rgba" val

constructCellRendererCellBackgroundRgba :: Gdk.RGBA -> IO ([Char], GValue)
constructCellRendererCellBackgroundRgba val = constructObjectPropertyBoxed "cell-background-rgba" val

data CellRendererCellBackgroundRgbaPropertyInfo
instance AttrInfo CellRendererCellBackgroundRgbaPropertyInfo where
    type AttrAllowedOps CellRendererCellBackgroundRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererCellBackgroundRgbaPropertyInfo = (~) Gdk.RGBA
    type AttrBaseTypeConstraint CellRendererCellBackgroundRgbaPropertyInfo = CellRendererK
    type AttrGetType CellRendererCellBackgroundRgbaPropertyInfo = Gdk.RGBA
    type AttrLabel CellRendererCellBackgroundRgbaPropertyInfo = "CellRenderer::cell-background-rgba"
    attrGet _ = getCellRendererCellBackgroundRgba
    attrSet _ = setCellRendererCellBackgroundRgba
    attrConstruct _ = constructCellRendererCellBackgroundRgba

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

getCellRendererCellBackgroundSet :: (MonadIO m, CellRendererK o) => o -> m Bool
getCellRendererCellBackgroundSet obj = liftIO $ getObjectPropertyBool obj "cell-background-set"

setCellRendererCellBackgroundSet :: (MonadIO m, CellRendererK o) => o -> Bool -> m ()
setCellRendererCellBackgroundSet obj val = liftIO $ setObjectPropertyBool obj "cell-background-set" val

constructCellRendererCellBackgroundSet :: Bool -> IO ([Char], GValue)
constructCellRendererCellBackgroundSet val = constructObjectPropertyBool "cell-background-set" val

data CellRendererCellBackgroundSetPropertyInfo
instance AttrInfo CellRendererCellBackgroundSetPropertyInfo where
    type AttrAllowedOps CellRendererCellBackgroundSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererCellBackgroundSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint CellRendererCellBackgroundSetPropertyInfo = CellRendererK
    type AttrGetType CellRendererCellBackgroundSetPropertyInfo = Bool
    type AttrLabel CellRendererCellBackgroundSetPropertyInfo = "CellRenderer::cell-background-set"
    attrGet _ = getCellRendererCellBackgroundSet
    attrSet _ = setCellRendererCellBackgroundSet
    attrConstruct _ = constructCellRendererCellBackgroundSet

-- VVV Prop "editing"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]

getCellRendererEditing :: (MonadIO m, CellRendererK o) => o -> m Bool
getCellRendererEditing obj = liftIO $ getObjectPropertyBool obj "editing"

data CellRendererEditingPropertyInfo
instance AttrInfo CellRendererEditingPropertyInfo where
    type AttrAllowedOps CellRendererEditingPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint CellRendererEditingPropertyInfo = (~) ()
    type AttrBaseTypeConstraint CellRendererEditingPropertyInfo = CellRendererK
    type AttrGetType CellRendererEditingPropertyInfo = Bool
    type AttrLabel CellRendererEditingPropertyInfo = "CellRenderer::editing"
    attrGet _ = getCellRendererEditing
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "height"
   -- Type: TBasicType TInt32
   -- Flags: [PropertyReadable,PropertyWritable]

getCellRendererHeight :: (MonadIO m, CellRendererK o) => o -> m Int32
getCellRendererHeight obj = liftIO $ getObjectPropertyCInt obj "height"

setCellRendererHeight :: (MonadIO m, CellRendererK o) => o -> Int32 -> m ()
setCellRendererHeight obj val = liftIO $ setObjectPropertyCInt obj "height" val

constructCellRendererHeight :: Int32 -> IO ([Char], GValue)
constructCellRendererHeight val = constructObjectPropertyCInt "height" val

data CellRendererHeightPropertyInfo
instance AttrInfo CellRendererHeightPropertyInfo where
    type AttrAllowedOps CellRendererHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererHeightPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint CellRendererHeightPropertyInfo = CellRendererK
    type AttrGetType CellRendererHeightPropertyInfo = Int32
    type AttrLabel CellRendererHeightPropertyInfo = "CellRenderer::height"
    attrGet _ = getCellRendererHeight
    attrSet _ = setCellRendererHeight
    attrConstruct _ = constructCellRendererHeight

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

getCellRendererIsExpanded :: (MonadIO m, CellRendererK o) => o -> m Bool
getCellRendererIsExpanded obj = liftIO $ getObjectPropertyBool obj "is-expanded"

setCellRendererIsExpanded :: (MonadIO m, CellRendererK o) => o -> Bool -> m ()
setCellRendererIsExpanded obj val = liftIO $ setObjectPropertyBool obj "is-expanded" val

constructCellRendererIsExpanded :: Bool -> IO ([Char], GValue)
constructCellRendererIsExpanded val = constructObjectPropertyBool "is-expanded" val

data CellRendererIsExpandedPropertyInfo
instance AttrInfo CellRendererIsExpandedPropertyInfo where
    type AttrAllowedOps CellRendererIsExpandedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererIsExpandedPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint CellRendererIsExpandedPropertyInfo = CellRendererK
    type AttrGetType CellRendererIsExpandedPropertyInfo = Bool
    type AttrLabel CellRendererIsExpandedPropertyInfo = "CellRenderer::is-expanded"
    attrGet _ = getCellRendererIsExpanded
    attrSet _ = setCellRendererIsExpanded
    attrConstruct _ = constructCellRendererIsExpanded

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

getCellRendererIsExpander :: (MonadIO m, CellRendererK o) => o -> m Bool
getCellRendererIsExpander obj = liftIO $ getObjectPropertyBool obj "is-expander"

setCellRendererIsExpander :: (MonadIO m, CellRendererK o) => o -> Bool -> m ()
setCellRendererIsExpander obj val = liftIO $ setObjectPropertyBool obj "is-expander" val

constructCellRendererIsExpander :: Bool -> IO ([Char], GValue)
constructCellRendererIsExpander val = constructObjectPropertyBool "is-expander" val

data CellRendererIsExpanderPropertyInfo
instance AttrInfo CellRendererIsExpanderPropertyInfo where
    type AttrAllowedOps CellRendererIsExpanderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererIsExpanderPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint CellRendererIsExpanderPropertyInfo = CellRendererK
    type AttrGetType CellRendererIsExpanderPropertyInfo = Bool
    type AttrLabel CellRendererIsExpanderPropertyInfo = "CellRenderer::is-expander"
    attrGet _ = getCellRendererIsExpander
    attrSet _ = setCellRendererIsExpander
    attrConstruct _ = constructCellRendererIsExpander

-- VVV Prop "mode"
   -- Type: TInterface "Gtk" "CellRendererMode"
   -- Flags: [PropertyReadable,PropertyWritable]

getCellRendererMode :: (MonadIO m, CellRendererK o) => o -> m CellRendererMode
getCellRendererMode obj = liftIO $ getObjectPropertyEnum obj "mode"

setCellRendererMode :: (MonadIO m, CellRendererK o) => o -> CellRendererMode -> m ()
setCellRendererMode obj val = liftIO $ setObjectPropertyEnum obj "mode" val

constructCellRendererMode :: CellRendererMode -> IO ([Char], GValue)
constructCellRendererMode val = constructObjectPropertyEnum "mode" val

data CellRendererModePropertyInfo
instance AttrInfo CellRendererModePropertyInfo where
    type AttrAllowedOps CellRendererModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererModePropertyInfo = (~) CellRendererMode
    type AttrBaseTypeConstraint CellRendererModePropertyInfo = CellRendererK
    type AttrGetType CellRendererModePropertyInfo = CellRendererMode
    type AttrLabel CellRendererModePropertyInfo = "CellRenderer::mode"
    attrGet _ = getCellRendererMode
    attrSet _ = setCellRendererMode
    attrConstruct _ = constructCellRendererMode

-- VVV Prop "sensitive"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]

getCellRendererSensitive :: (MonadIO m, CellRendererK o) => o -> m Bool
getCellRendererSensitive obj = liftIO $ getObjectPropertyBool obj "sensitive"

setCellRendererSensitive :: (MonadIO m, CellRendererK o) => o -> Bool -> m ()
setCellRendererSensitive obj val = liftIO $ setObjectPropertyBool obj "sensitive" val

constructCellRendererSensitive :: Bool -> IO ([Char], GValue)
constructCellRendererSensitive val = constructObjectPropertyBool "sensitive" val

data CellRendererSensitivePropertyInfo
instance AttrInfo CellRendererSensitivePropertyInfo where
    type AttrAllowedOps CellRendererSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererSensitivePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint CellRendererSensitivePropertyInfo = CellRendererK
    type AttrGetType CellRendererSensitivePropertyInfo = Bool
    type AttrLabel CellRendererSensitivePropertyInfo = "CellRenderer::sensitive"
    attrGet _ = getCellRendererSensitive
    attrSet _ = setCellRendererSensitive
    attrConstruct _ = constructCellRendererSensitive

-- VVV Prop "visible"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]

getCellRendererVisible :: (MonadIO m, CellRendererK o) => o -> m Bool
getCellRendererVisible obj = liftIO $ getObjectPropertyBool obj "visible"

setCellRendererVisible :: (MonadIO m, CellRendererK o) => o -> Bool -> m ()
setCellRendererVisible obj val = liftIO $ setObjectPropertyBool obj "visible" val

constructCellRendererVisible :: Bool -> IO ([Char], GValue)
constructCellRendererVisible val = constructObjectPropertyBool "visible" val

data CellRendererVisiblePropertyInfo
instance AttrInfo CellRendererVisiblePropertyInfo where
    type AttrAllowedOps CellRendererVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererVisiblePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint CellRendererVisiblePropertyInfo = CellRendererK
    type AttrGetType CellRendererVisiblePropertyInfo = Bool
    type AttrLabel CellRendererVisiblePropertyInfo = "CellRenderer::visible"
    attrGet _ = getCellRendererVisible
    attrSet _ = setCellRendererVisible
    attrConstruct _ = constructCellRendererVisible

-- VVV Prop "width"
   -- Type: TBasicType TInt32
   -- Flags: [PropertyReadable,PropertyWritable]

getCellRendererWidth :: (MonadIO m, CellRendererK o) => o -> m Int32
getCellRendererWidth obj = liftIO $ getObjectPropertyCInt obj "width"

setCellRendererWidth :: (MonadIO m, CellRendererK o) => o -> Int32 -> m ()
setCellRendererWidth obj val = liftIO $ setObjectPropertyCInt obj "width" val

constructCellRendererWidth :: Int32 -> IO ([Char], GValue)
constructCellRendererWidth val = constructObjectPropertyCInt "width" val

data CellRendererWidthPropertyInfo
instance AttrInfo CellRendererWidthPropertyInfo where
    type AttrAllowedOps CellRendererWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererWidthPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint CellRendererWidthPropertyInfo = CellRendererK
    type AttrGetType CellRendererWidthPropertyInfo = Int32
    type AttrLabel CellRendererWidthPropertyInfo = "CellRenderer::width"
    attrGet _ = getCellRendererWidth
    attrSet _ = setCellRendererWidth
    attrConstruct _ = constructCellRendererWidth

-- VVV Prop "xalign"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]

getCellRendererXalign :: (MonadIO m, CellRendererK o) => o -> m Float
getCellRendererXalign obj = liftIO $ getObjectPropertyFloat obj "xalign"

setCellRendererXalign :: (MonadIO m, CellRendererK o) => o -> Float -> m ()
setCellRendererXalign obj val = liftIO $ setObjectPropertyFloat obj "xalign" val

constructCellRendererXalign :: Float -> IO ([Char], GValue)
constructCellRendererXalign val = constructObjectPropertyFloat "xalign" val

data CellRendererXalignPropertyInfo
instance AttrInfo CellRendererXalignPropertyInfo where
    type AttrAllowedOps CellRendererXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererXalignPropertyInfo = (~) Float
    type AttrBaseTypeConstraint CellRendererXalignPropertyInfo = CellRendererK
    type AttrGetType CellRendererXalignPropertyInfo = Float
    type AttrLabel CellRendererXalignPropertyInfo = "CellRenderer::xalign"
    attrGet _ = getCellRendererXalign
    attrSet _ = setCellRendererXalign
    attrConstruct _ = constructCellRendererXalign

-- VVV Prop "xpad"
   -- Type: TBasicType TUInt32
   -- Flags: [PropertyReadable,PropertyWritable]

getCellRendererXpad :: (MonadIO m, CellRendererK o) => o -> m Word32
getCellRendererXpad obj = liftIO $ getObjectPropertyCUInt obj "xpad"

setCellRendererXpad :: (MonadIO m, CellRendererK o) => o -> Word32 -> m ()
setCellRendererXpad obj val = liftIO $ setObjectPropertyCUInt obj "xpad" val

constructCellRendererXpad :: Word32 -> IO ([Char], GValue)
constructCellRendererXpad val = constructObjectPropertyCUInt "xpad" val

data CellRendererXpadPropertyInfo
instance AttrInfo CellRendererXpadPropertyInfo where
    type AttrAllowedOps CellRendererXpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererXpadPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint CellRendererXpadPropertyInfo = CellRendererK
    type AttrGetType CellRendererXpadPropertyInfo = Word32
    type AttrLabel CellRendererXpadPropertyInfo = "CellRenderer::xpad"
    attrGet _ = getCellRendererXpad
    attrSet _ = setCellRendererXpad
    attrConstruct _ = constructCellRendererXpad

-- VVV Prop "yalign"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]

getCellRendererYalign :: (MonadIO m, CellRendererK o) => o -> m Float
getCellRendererYalign obj = liftIO $ getObjectPropertyFloat obj "yalign"

setCellRendererYalign :: (MonadIO m, CellRendererK o) => o -> Float -> m ()
setCellRendererYalign obj val = liftIO $ setObjectPropertyFloat obj "yalign" val

constructCellRendererYalign :: Float -> IO ([Char], GValue)
constructCellRendererYalign val = constructObjectPropertyFloat "yalign" val

data CellRendererYalignPropertyInfo
instance AttrInfo CellRendererYalignPropertyInfo where
    type AttrAllowedOps CellRendererYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererYalignPropertyInfo = (~) Float
    type AttrBaseTypeConstraint CellRendererYalignPropertyInfo = CellRendererK
    type AttrGetType CellRendererYalignPropertyInfo = Float
    type AttrLabel CellRendererYalignPropertyInfo = "CellRenderer::yalign"
    attrGet _ = getCellRendererYalign
    attrSet _ = setCellRendererYalign
    attrConstruct _ = constructCellRendererYalign

-- VVV Prop "ypad"
   -- Type: TBasicType TUInt32
   -- Flags: [PropertyReadable,PropertyWritable]

getCellRendererYpad :: (MonadIO m, CellRendererK o) => o -> m Word32
getCellRendererYpad obj = liftIO $ getObjectPropertyCUInt obj "ypad"

setCellRendererYpad :: (MonadIO m, CellRendererK o) => o -> Word32 -> m ()
setCellRendererYpad obj val = liftIO $ setObjectPropertyCUInt obj "ypad" val

constructCellRendererYpad :: Word32 -> IO ([Char], GValue)
constructCellRendererYpad val = constructObjectPropertyCUInt "ypad" val

data CellRendererYpadPropertyInfo
instance AttrInfo CellRendererYpadPropertyInfo where
    type AttrAllowedOps CellRendererYpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CellRendererYpadPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint CellRendererYpadPropertyInfo = CellRendererK
    type AttrGetType CellRendererYpadPropertyInfo = Word32
    type AttrLabel CellRendererYpadPropertyInfo = "CellRenderer::ypad"
    attrGet _ = getCellRendererYpad
    attrSet _ = setCellRendererYpad
    attrConstruct _ = constructCellRendererYpad

type instance AttributeList CellRenderer = CellRendererAttributeList
type CellRendererAttributeList = ('[ '("cell-background", CellRendererCellBackgroundPropertyInfo), '("cell-background-gdk", CellRendererCellBackgroundGdkPropertyInfo), '("cell-background-rgba", CellRendererCellBackgroundRgbaPropertyInfo), '("cell-background-set", CellRendererCellBackgroundSetPropertyInfo), '("editing", CellRendererEditingPropertyInfo), '("height", CellRendererHeightPropertyInfo), '("is-expanded", CellRendererIsExpandedPropertyInfo), '("is-expander", CellRendererIsExpanderPropertyInfo), '("mode", CellRendererModePropertyInfo), '("sensitive", CellRendererSensitivePropertyInfo), '("visible", CellRendererVisiblePropertyInfo), '("width", CellRendererWidthPropertyInfo), '("xalign", CellRendererXalignPropertyInfo), '("xpad", CellRendererXpadPropertyInfo), '("yalign", CellRendererYalignPropertyInfo), '("ypad", CellRendererYpadPropertyInfo)] :: [(Symbol, *)])

data CellRendererEditingCanceledSignalInfo
instance SignalInfo CellRendererEditingCanceledSignalInfo where
    type HaskellCallbackType CellRendererEditingCanceledSignalInfo = CellRendererEditingCanceledCallback
    connectSignal _ = connectCellRendererEditingCanceled

data CellRendererEditingStartedSignalInfo
instance SignalInfo CellRendererEditingStartedSignalInfo where
    type HaskellCallbackType CellRendererEditingStartedSignalInfo = CellRendererEditingStartedCallback
    connectSignal _ = connectCellRendererEditingStarted

type instance SignalList CellRenderer = CellRendererSignalList
type CellRendererSignalList = ('[ '("editing-canceled", CellRendererEditingCanceledSignalInfo), '("editing-started", CellRendererEditingStartedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method CellRenderer::activate
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_activate" gtk_cell_renderer_activate :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Gdk.Event ->                        -- event : TInterface "Gdk" "Event"
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    CString ->                              -- path : TBasicType TUTF8
    Ptr Gdk.Rectangle ->                    -- background_area : TInterface "Gdk" "Rectangle"
    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"
    CUInt ->                                -- flags : TInterface "Gtk" "CellRendererState"
    IO CInt


cellRendererActivate ::
    (MonadIO m, CellRendererK a, WidgetK b) =>
    a ->                                    -- _obj
    Gdk.Event ->                            -- event
    b ->                                    -- widget
    T.Text ->                               -- path
    Gdk.Rectangle ->                        -- background_area
    Gdk.Rectangle ->                        -- cell_area
    [CellRendererState] ->                  -- flags
    m Bool
cellRendererActivate _obj event widget path background_area cell_area flags = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let event' = unsafeManagedPtrGetPtr event
    let widget' = unsafeManagedPtrCastPtr widget
    path' <- textToCString path
    let background_area' = unsafeManagedPtrGetPtr background_area
    let cell_area' = unsafeManagedPtrGetPtr cell_area
    let flags' = gflagsToWord flags
    result <- gtk_cell_renderer_activate _obj' event' widget' path' background_area' cell_area' flags'
    let result' = (/= 0) result
    touchManagedPtr _obj
    touchManagedPtr event
    touchManagedPtr widget
    touchManagedPtr background_area
    touchManagedPtr cell_area
    freeMem path'
    return result'

-- method CellRenderer::get_aligned_area
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "aligned_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_aligned_area" gtk_cell_renderer_get_aligned_area :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    CUInt ->                                -- flags : TInterface "Gtk" "CellRendererState"
    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"
    Ptr Gdk.Rectangle ->                    -- aligned_area : TInterface "Gdk" "Rectangle"
    IO ()


cellRendererGetAlignedArea ::
    (MonadIO m, CellRendererK a, WidgetK b) =>
    a ->                                    -- _obj
    b ->                                    -- widget
    [CellRendererState] ->                  -- flags
    Gdk.Rectangle ->                        -- cell_area
    m (Gdk.Rectangle)
cellRendererGetAlignedArea _obj widget flags cell_area = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let widget' = unsafeManagedPtrCastPtr widget
    let flags' = gflagsToWord flags
    let cell_area' = unsafeManagedPtrGetPtr cell_area
    aligned_area <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)
    gtk_cell_renderer_get_aligned_area _obj' widget' flags' cell_area' aligned_area
    aligned_area' <- (wrapBoxed Gdk.Rectangle) aligned_area
    touchManagedPtr _obj
    touchManagedPtr widget
    touchManagedPtr cell_area
    return aligned_area'

-- method CellRenderer::get_alignment
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_alignment" gtk_cell_renderer_get_alignment :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr CFloat ->                           -- xalign : TBasicType TFloat
    Ptr CFloat ->                           -- yalign : TBasicType TFloat
    IO ()


cellRendererGetAlignment ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    m (Float,Float)
cellRendererGetAlignment _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    xalign <- allocMem :: IO (Ptr CFloat)
    yalign <- allocMem :: IO (Ptr CFloat)
    gtk_cell_renderer_get_alignment _obj' xalign yalign
    xalign' <- peek xalign
    let xalign'' = realToFrac xalign'
    yalign' <- peek yalign
    let yalign'' = realToFrac yalign'
    touchManagedPtr _obj
    freeMem xalign
    freeMem yalign
    return (xalign'', yalign'')

-- method CellRenderer::get_fixed_size
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_fixed_size" gtk_cell_renderer_get_fixed_size :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Int32 ->                            -- width : TBasicType TInt32
    Ptr Int32 ->                            -- height : TBasicType TInt32
    IO ()


cellRendererGetFixedSize ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    m (Int32,Int32)
cellRendererGetFixedSize _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    width <- allocMem :: IO (Ptr Int32)
    height <- allocMem :: IO (Ptr Int32)
    gtk_cell_renderer_get_fixed_size _obj' width height
    width' <- peek width
    height' <- peek height
    touchManagedPtr _obj
    freeMem width
    freeMem height
    return (width', height')

-- method CellRenderer::get_padding
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xpad", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "ypad", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_padding" gtk_cell_renderer_get_padding :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Int32 ->                            -- xpad : TBasicType TInt32
    Ptr Int32 ->                            -- ypad : TBasicType TInt32
    IO ()


cellRendererGetPadding ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    m (Int32,Int32)
cellRendererGetPadding _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    xpad <- allocMem :: IO (Ptr Int32)
    ypad <- allocMem :: IO (Ptr Int32)
    gtk_cell_renderer_get_padding _obj' xpad ypad
    xpad' <- peek xpad
    ypad' <- peek ypad
    touchManagedPtr _obj
    freeMem xpad
    freeMem ypad
    return (xpad', ypad')

-- method CellRenderer::get_preferred_height
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_preferred_height" gtk_cell_renderer_get_preferred_height :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    Ptr Int32 ->                            -- minimum_size : TBasicType TInt32
    Ptr Int32 ->                            -- natural_size : TBasicType TInt32
    IO ()


cellRendererGetPreferredHeight ::
    (MonadIO m, CellRendererK a, WidgetK b) =>
    a ->                                    -- _obj
    b ->                                    -- widget
    m (Int32,Int32)
cellRendererGetPreferredHeight _obj widget = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let widget' = unsafeManagedPtrCastPtr widget
    minimum_size <- allocMem :: IO (Ptr Int32)
    natural_size <- allocMem :: IO (Ptr Int32)
    gtk_cell_renderer_get_preferred_height _obj' widget' minimum_size natural_size
    minimum_size' <- peek minimum_size
    natural_size' <- peek natural_size
    touchManagedPtr _obj
    touchManagedPtr widget
    freeMem minimum_size
    freeMem natural_size
    return (minimum_size', natural_size')

-- method CellRenderer::get_preferred_height_for_width
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- 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 ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    Int32 ->                                -- width : TBasicType TInt32
    Ptr Int32 ->                            -- minimum_height : TBasicType TInt32
    Ptr Int32 ->                            -- natural_height : TBasicType TInt32
    IO ()


cellRendererGetPreferredHeightForWidth ::
    (MonadIO m, CellRendererK a, WidgetK b) =>
    a ->                                    -- _obj
    b ->                                    -- widget
    Int32 ->                                -- width
    m (Int32,Int32)
cellRendererGetPreferredHeightForWidth _obj widget width = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let widget' = unsafeManagedPtrCastPtr widget
    minimum_height <- allocMem :: IO (Ptr Int32)
    natural_height <- allocMem :: IO (Ptr Int32)
    gtk_cell_renderer_get_preferred_height_for_width _obj' widget' width minimum_height natural_height
    minimum_height' <- peek minimum_height
    natural_height' <- peek natural_height
    touchManagedPtr _obj
    touchManagedPtr widget
    freeMem minimum_height
    freeMem natural_height
    return (minimum_height', natural_height')

-- method CellRenderer::get_preferred_size
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_size", argType = TInterface "Gtk" "Requisition", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "natural_size", argType = TInterface "Gtk" "Requisition", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_preferred_size" gtk_cell_renderer_get_preferred_size :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    Ptr Requisition ->                      -- minimum_size : TInterface "Gtk" "Requisition"
    Ptr Requisition ->                      -- natural_size : TInterface "Gtk" "Requisition"
    IO ()


cellRendererGetPreferredSize ::
    (MonadIO m, CellRendererK a, WidgetK b) =>
    a ->                                    -- _obj
    b ->                                    -- widget
    m (Requisition,Requisition)
cellRendererGetPreferredSize _obj widget = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let widget' = unsafeManagedPtrCastPtr widget
    minimum_size <- callocBoxedBytes 8 :: IO (Ptr Requisition)
    natural_size <- callocBoxedBytes 8 :: IO (Ptr Requisition)
    gtk_cell_renderer_get_preferred_size _obj' widget' minimum_size natural_size
    minimum_size' <- (wrapBoxed Requisition) minimum_size
    natural_size' <- (wrapBoxed Requisition) natural_size
    touchManagedPtr _obj
    touchManagedPtr widget
    return (minimum_size', natural_size')

-- method CellRenderer::get_preferred_width
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_preferred_width" gtk_cell_renderer_get_preferred_width :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    Ptr Int32 ->                            -- minimum_size : TBasicType TInt32
    Ptr Int32 ->                            -- natural_size : TBasicType TInt32
    IO ()


cellRendererGetPreferredWidth ::
    (MonadIO m, CellRendererK a, WidgetK b) =>
    a ->                                    -- _obj
    b ->                                    -- widget
    m (Int32,Int32)
cellRendererGetPreferredWidth _obj widget = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let widget' = unsafeManagedPtrCastPtr widget
    minimum_size <- allocMem :: IO (Ptr Int32)
    natural_size <- allocMem :: IO (Ptr Int32)
    gtk_cell_renderer_get_preferred_width _obj' widget' minimum_size natural_size
    minimum_size' <- peek minimum_size
    natural_size' <- peek natural_size
    touchManagedPtr _obj
    touchManagedPtr widget
    freeMem minimum_size
    freeMem natural_size
    return (minimum_size', natural_size')

-- method CellRenderer::get_preferred_width_for_height
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- 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 ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    Int32 ->                                -- height : TBasicType TInt32
    Ptr Int32 ->                            -- minimum_width : TBasicType TInt32
    Ptr Int32 ->                            -- natural_width : TBasicType TInt32
    IO ()


cellRendererGetPreferredWidthForHeight ::
    (MonadIO m, CellRendererK a, WidgetK b) =>
    a ->                                    -- _obj
    b ->                                    -- widget
    Int32 ->                                -- height
    m (Int32,Int32)
cellRendererGetPreferredWidthForHeight _obj widget height = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let widget' = unsafeManagedPtrCastPtr widget
    minimum_width <- allocMem :: IO (Ptr Int32)
    natural_width <- allocMem :: IO (Ptr Int32)
    gtk_cell_renderer_get_preferred_width_for_height _obj' widget' height minimum_width natural_width
    minimum_width' <- peek minimum_width
    natural_width' <- peek natural_width
    touchManagedPtr _obj
    touchManagedPtr widget
    freeMem minimum_width
    freeMem natural_width
    return (minimum_width', natural_width')

-- method CellRenderer::get_request_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Gtk" "SizeRequestMode"
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_request_mode" gtk_cell_renderer_get_request_mode :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    IO CUInt


cellRendererGetRequestMode ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    m SizeRequestMode
cellRendererGetRequestMode _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- gtk_cell_renderer_get_request_mode _obj'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr _obj
    return result'

-- method CellRenderer::get_sensitive
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_sensitive" gtk_cell_renderer_get_sensitive :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    IO CInt


cellRendererGetSensitive ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    m Bool
cellRendererGetSensitive _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- gtk_cell_renderer_get_sensitive _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method CellRenderer::get_size
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x_offset", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "y_offset", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_size" gtk_cell_renderer_get_size :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"
    Ptr Int32 ->                            -- x_offset : TBasicType TInt32
    Ptr Int32 ->                            -- y_offset : TBasicType TInt32
    Ptr Int32 ->                            -- width : TBasicType TInt32
    Ptr Int32 ->                            -- height : TBasicType TInt32
    IO ()

{-# DEPRECATED cellRendererGetSize ["(Since version 3.0)","Use gtk_cell_renderer_get_preferred_size() instead."]#-}
cellRendererGetSize ::
    (MonadIO m, CellRendererK a, WidgetK b) =>
    a ->                                    -- _obj
    b ->                                    -- widget
    Maybe (Gdk.Rectangle) ->                -- cell_area
    m (Int32,Int32,Int32,Int32)
cellRendererGetSize _obj widget cell_area = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let widget' = unsafeManagedPtrCastPtr widget
    maybeCell_area <- case cell_area of
        Nothing -> return nullPtr
        Just jCell_area -> do
            let jCell_area' = unsafeManagedPtrGetPtr jCell_area
            return jCell_area'
    x_offset <- allocMem :: IO (Ptr Int32)
    y_offset <- allocMem :: IO (Ptr Int32)
    width <- allocMem :: IO (Ptr Int32)
    height <- allocMem :: IO (Ptr Int32)
    gtk_cell_renderer_get_size _obj' widget' maybeCell_area x_offset y_offset width height
    x_offset' <- peek x_offset
    y_offset' <- peek y_offset
    width' <- peek width
    height' <- peek height
    touchManagedPtr _obj
    touchManagedPtr widget
    whenJust cell_area touchManagedPtr
    freeMem x_offset
    freeMem y_offset
    freeMem width
    freeMem height
    return (x_offset', y_offset', width', height')

-- method CellRenderer::get_state
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_state", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_state", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Gtk" "StateFlags"
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_state" gtk_cell_renderer_get_state :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    CUInt ->                                -- cell_state : TInterface "Gtk" "CellRendererState"
    IO CUInt


cellRendererGetState ::
    (MonadIO m, CellRendererK a, WidgetK b) =>
    a ->                                    -- _obj
    b ->                                    -- widget
    [CellRendererState] ->                  -- cell_state
    m [StateFlags]
cellRendererGetState _obj widget cell_state = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let widget' = unsafeManagedPtrCastPtr widget
    let cell_state' = gflagsToWord cell_state
    result <- gtk_cell_renderer_get_state _obj' widget' cell_state'
    let result' = wordToGFlags result
    touchManagedPtr _obj
    touchManagedPtr widget
    return result'

-- method CellRenderer::get_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_get_visible" gtk_cell_renderer_get_visible :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    IO CInt


cellRendererGetVisible ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    m Bool
cellRendererGetVisible _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- gtk_cell_renderer_get_visible _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method CellRenderer::is_activatable
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_is_activatable" gtk_cell_renderer_is_activatable :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    IO CInt


cellRendererIsActivatable ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    m Bool
cellRendererIsActivatable _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- gtk_cell_renderer_is_activatable _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method CellRenderer::render
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_render" gtk_cell_renderer_render :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    Ptr Gdk.Rectangle ->                    -- background_area : TInterface "Gdk" "Rectangle"
    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"
    CUInt ->                                -- flags : TInterface "Gtk" "CellRendererState"
    IO ()


cellRendererRender ::
    (MonadIO m, CellRendererK a, WidgetK b) =>
    a ->                                    -- _obj
    Cairo.Context ->                        -- cr
    b ->                                    -- widget
    Gdk.Rectangle ->                        -- background_area
    Gdk.Rectangle ->                        -- cell_area
    [CellRendererState] ->                  -- flags
    m ()
cellRendererRender _obj cr widget background_area cell_area flags = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let cr' = unsafeManagedPtrGetPtr cr
    let widget' = unsafeManagedPtrCastPtr widget
    let background_area' = unsafeManagedPtrGetPtr background_area
    let cell_area' = unsafeManagedPtrGetPtr cell_area
    let flags' = gflagsToWord flags
    gtk_cell_renderer_render _obj' cr' widget' background_area' cell_area' flags'
    touchManagedPtr _obj
    touchManagedPtr cr
    touchManagedPtr widget
    touchManagedPtr background_area
    touchManagedPtr cell_area
    return ()

-- method CellRenderer::set_alignment
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_set_alignment" gtk_cell_renderer_set_alignment :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    CFloat ->                               -- xalign : TBasicType TFloat
    CFloat ->                               -- yalign : TBasicType TFloat
    IO ()


cellRendererSetAlignment ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    Float ->                                -- xalign
    Float ->                                -- yalign
    m ()
cellRendererSetAlignment _obj xalign yalign = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let xalign' = realToFrac xalign
    let yalign' = realToFrac yalign
    gtk_cell_renderer_set_alignment _obj' xalign' yalign'
    touchManagedPtr _obj
    return ()

-- method CellRenderer::set_fixed_size
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_set_fixed_size" gtk_cell_renderer_set_fixed_size :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Int32 ->                                -- width : TBasicType TInt32
    Int32 ->                                -- height : TBasicType TInt32
    IO ()


cellRendererSetFixedSize ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    Int32 ->                                -- width
    Int32 ->                                -- height
    m ()
cellRendererSetFixedSize _obj width height = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    gtk_cell_renderer_set_fixed_size _obj' width height
    touchManagedPtr _obj
    return ()

-- method CellRenderer::set_padding
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xpad", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ypad", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xpad", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ypad", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_set_padding" gtk_cell_renderer_set_padding :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Int32 ->                                -- xpad : TBasicType TInt32
    Int32 ->                                -- ypad : TBasicType TInt32
    IO ()


cellRendererSetPadding ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    Int32 ->                                -- xpad
    Int32 ->                                -- ypad
    m ()
cellRendererSetPadding _obj xpad ypad = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    gtk_cell_renderer_set_padding _obj' xpad ypad
    touchManagedPtr _obj
    return ()

-- method CellRenderer::set_sensitive
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_set_sensitive" gtk_cell_renderer_set_sensitive :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    CInt ->                                 -- sensitive : TBasicType TBoolean
    IO ()


cellRendererSetSensitive ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- sensitive
    m ()
cellRendererSetSensitive _obj sensitive = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let sensitive' = (fromIntegral . fromEnum) sensitive
    gtk_cell_renderer_set_sensitive _obj' sensitive'
    touchManagedPtr _obj
    return ()

-- method CellRenderer::set_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_set_visible" gtk_cell_renderer_set_visible :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()


cellRendererSetVisible ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- visible
    m ()
cellRendererSetVisible _obj visible = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let visible' = (fromIntegral . fromEnum) visible
    gtk_cell_renderer_set_visible _obj' visible'
    touchManagedPtr _obj
    return ()

-- method CellRenderer::start_editing
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Gtk" "CellEditable"
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_start_editing" gtk_cell_renderer_start_editing :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    Ptr Gdk.Event ->                        -- event : TInterface "Gdk" "Event"
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    CString ->                              -- path : TBasicType TUTF8
    Ptr Gdk.Rectangle ->                    -- background_area : TInterface "Gdk" "Rectangle"
    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"
    CUInt ->                                -- flags : TInterface "Gtk" "CellRendererState"
    IO (Ptr CellEditable)


cellRendererStartEditing ::
    (MonadIO m, CellRendererK a, WidgetK b) =>
    a ->                                    -- _obj
    Gdk.Event ->                            -- event
    b ->                                    -- widget
    T.Text ->                               -- path
    Gdk.Rectangle ->                        -- background_area
    Gdk.Rectangle ->                        -- cell_area
    [CellRendererState] ->                  -- flags
    m CellEditable
cellRendererStartEditing _obj event widget path background_area cell_area flags = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let event' = unsafeManagedPtrGetPtr event
    let widget' = unsafeManagedPtrCastPtr widget
    path' <- textToCString path
    let background_area' = unsafeManagedPtrGetPtr background_area
    let cell_area' = unsafeManagedPtrGetPtr cell_area
    let flags' = gflagsToWord flags
    result <- gtk_cell_renderer_start_editing _obj' event' widget' path' background_area' cell_area' flags'
    checkUnexpectedReturnNULL "gtk_cell_renderer_start_editing" result
    result' <- (newObject CellEditable) result
    touchManagedPtr _obj
    touchManagedPtr event
    touchManagedPtr widget
    touchManagedPtr background_area
    touchManagedPtr cell_area
    freeMem path'
    return result'

-- method CellRenderer::stop_editing
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "canceled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "canceled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_cell_renderer_stop_editing" gtk_cell_renderer_stop_editing :: 
    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"
    CInt ->                                 -- canceled : TBasicType TBoolean
    IO ()


cellRendererStopEditing ::
    (MonadIO m, CellRendererK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- canceled
    m ()
cellRendererStopEditing _obj canceled = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let canceled' = (fromIntegral . fromEnum) canceled
    gtk_cell_renderer_stop_editing _obj' canceled'
    touchManagedPtr _obj
    return ()