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

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- t'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle' renders a toggle button in a cell. The
    -- button is drawn as a radio or a checkbutton, depending on the
    -- [CellRendererToggle:radio]("GI.Gtk.Objects.CellRendererToggle#g:attr:radio") property.
    -- When activated, it emits the [CellRendererToggle::toggled]("GI.Gtk.Objects.CellRendererToggle#g:signal:toggled") signal.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gtk.Objects.CellRendererToggle
        (

    -- * Exported types
        CellRendererToggle(..)                  ,
        IsCellRendererToggle                    ,
        toCellRendererToggle                    ,

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

    #if defined(ENABLE_OVERLOADING)
        ResolveCellRendererToggleMethod         ,
    #endif

    -- ** getActivatable #method:getActivatable#

    #if defined(ENABLE_OVERLOADING)
        CellRendererToggleGetActivatableMethodInfo,
    #endif
        cellRendererToggleGetActivatable        ,

    -- ** getActive #method:getActive#

    #if defined(ENABLE_OVERLOADING)
        CellRendererToggleGetActiveMethodInfo   ,
    #endif
        cellRendererToggleGetActive             ,

    -- ** getRadio #method:getRadio#

    #if defined(ENABLE_OVERLOADING)
        CellRendererToggleGetRadioMethodInfo    ,
    #endif
        cellRendererToggleGetRadio              ,

    -- ** new #method:new#

        cellRendererToggleNew                   ,

    -- ** setActivatable #method:setActivatable#

    #if defined(ENABLE_OVERLOADING)
        CellRendererToggleSetActivatableMethodInfo,
    #endif
        cellRendererToggleSetActivatable        ,

    -- ** setActive #method:setActive#

    #if defined(ENABLE_OVERLOADING)
        CellRendererToggleSetActiveMethodInfo   ,
    #endif
        cellRendererToggleSetActive             ,

    -- ** setRadio #method:setRadio#

    #if defined(ENABLE_OVERLOADING)
        CellRendererToggleSetRadioMethodInfo    ,
    #endif
        cellRendererToggleSetRadio              ,

     -- * Properties

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

    #if defined(ENABLE_OVERLOADING)
        CellRendererToggleActivatablePropertyInfo,
    #endif
    #if defined(ENABLE_OVERLOADING)
        cellRendererToggleActivatable           ,
    #endif
        constructCellRendererToggleActivatable  ,
        getCellRendererToggleActivatable        ,
        setCellRendererToggleActivatable        ,

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

    #if defined(ENABLE_OVERLOADING)
        CellRendererToggleActivePropertyInfo    ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        cellRendererToggleActive                ,
    #endif
        constructCellRendererToggleActive       ,
        getCellRendererToggleActive             ,
        setCellRendererToggleActive             ,

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

    #if defined(ENABLE_OVERLOADING)
        CellRendererToggleInconsistentPropertyInfo,
    #endif
    #if defined(ENABLE_OVERLOADING)
        cellRendererToggleInconsistent          ,
    #endif
        constructCellRendererToggleInconsistent ,
        getCellRendererToggleInconsistent       ,
        setCellRendererToggleInconsistent       ,

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

    #if defined(ENABLE_OVERLOADING)
        CellRendererToggleIndicatorSizePropertyInfo,
    #endif
    #if defined(ENABLE_OVERLOADING)
        cellRendererToggleIndicatorSize         ,
    #endif
        constructCellRendererToggleIndicatorSize,
        getCellRendererToggleIndicatorSize      ,
        setCellRendererToggleIndicatorSize      ,

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

    #if defined(ENABLE_OVERLOADING)
        CellRendererToggleRadioPropertyInfo     ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        cellRendererToggleRadio                 ,
    #endif
        constructCellRendererToggleRadio        ,
        getCellRendererToggleRadio              ,
        setCellRendererToggleRadio              ,

     -- * Signals

    -- ** toggled #signal:toggled#

        CellRendererToggleToggledCallback       ,
    #if defined(ENABLE_OVERLOADING)
        CellRendererToggleToggledSignalInfo     ,
    #endif
        afterCellRendererToggleToggled          ,
        onCellRendererToggleToggled             ,

        ) where

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

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

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

    #else
    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gtk.Objects.CellRenderer as Gtk.CellRenderer

    #endif

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

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

    foreign import ccall "gtk_cell_renderer_toggle_get_type"
        c_gtk_cell_renderer_toggle_get_type :: IO B.Types.GType

    instance B.Types.TypedObject CellRendererToggle where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_cell_renderer_toggle_get_type

    instance B.Types.GObject CellRendererToggle

    -- | Type class for types which can be safely cast to t'CellRendererToggle', for instance with `toCellRendererToggle`.
    class (SP.GObject o, O.IsDescendantOf CellRendererToggle o) => IsCellRendererToggle o
    instance (SP.GObject o, O.IsDescendantOf CellRendererToggle o) => IsCellRendererToggle o

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

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

    -- | Convert t'CellRendererToggle' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue (Maybe CellRendererToggle) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_gtk_cell_renderer_toggle_get_type
        gvalueSet_ :: Ptr GValue -> Maybe CellRendererToggle -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe CellRendererToggle
    P.Nothing = Ptr GValue -> Ptr CellRendererToggle -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv (Ptr CellRendererToggle
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr CellRendererToggle)
        gvalueSet_ Ptr GValue
    gv (P.Just CellRendererToggle
    obj) = CellRendererToggle -> (Ptr CellRendererToggle -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr CellRendererToggle
    obj (Ptr GValue -> Ptr CellRendererToggle -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe CellRendererToggle)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr CellRendererToggle)
    forall a. GObject a => Ptr GValue -> IO (Ptr a)
    B.GValue.get_object Ptr GValue
    gv :: IO (FP.Ptr CellRendererToggle)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newObject CellRendererToggle ptr
            else return P.Nothing

    #if defined(ENABLE_OVERLOADING)
    type family ResolveCellRendererToggleMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveCellRendererToggleMethod "activate" o = Gtk.CellRenderer.CellRendererActivateMethodInfo
        ResolveCellRendererToggleMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveCellRendererToggleMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveCellRendererToggleMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveCellRendererToggleMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveCellRendererToggleMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveCellRendererToggleMethod "isActivatable" o = Gtk.CellRenderer.CellRendererIsActivatableMethodInfo
        ResolveCellRendererToggleMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveCellRendererToggleMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveCellRendererToggleMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveCellRendererToggleMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveCellRendererToggleMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveCellRendererToggleMethod "render" o = Gtk.CellRenderer.CellRendererRenderMethodInfo
        ResolveCellRendererToggleMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveCellRendererToggleMethod "startEditing" o = Gtk.CellRenderer.CellRendererStartEditingMethodInfo
        ResolveCellRendererToggleMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveCellRendererToggleMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveCellRendererToggleMethod "stopEditing" o = Gtk.CellRenderer.CellRendererStopEditingMethodInfo
        ResolveCellRendererToggleMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveCellRendererToggleMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveCellRendererToggleMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveCellRendererToggleMethod "getActivatable" o = CellRendererToggleGetActivatableMethodInfo
        ResolveCellRendererToggleMethod "getActive" o = CellRendererToggleGetActiveMethodInfo
        ResolveCellRendererToggleMethod "getAlignedArea" o = Gtk.CellRenderer.CellRendererGetAlignedAreaMethodInfo
        ResolveCellRendererToggleMethod "getAlignment" o = Gtk.CellRenderer.CellRendererGetAlignmentMethodInfo
        ResolveCellRendererToggleMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveCellRendererToggleMethod "getFixedSize" o = Gtk.CellRenderer.CellRendererGetFixedSizeMethodInfo
        ResolveCellRendererToggleMethod "getPadding" o = Gtk.CellRenderer.CellRendererGetPaddingMethodInfo
        ResolveCellRendererToggleMethod "getPreferredHeight" o = Gtk.CellRenderer.CellRendererGetPreferredHeightMethodInfo
        ResolveCellRendererToggleMethod "getPreferredHeightForWidth" o = Gtk.CellRenderer.CellRendererGetPreferredHeightForWidthMethodInfo
        ResolveCellRendererToggleMethod "getPreferredSize" o = Gtk.CellRenderer.CellRendererGetPreferredSizeMethodInfo
        ResolveCellRendererToggleMethod "getPreferredWidth" o = Gtk.CellRenderer.CellRendererGetPreferredWidthMethodInfo
        ResolveCellRendererToggleMethod "getPreferredWidthForHeight" o = Gtk.CellRenderer.CellRendererGetPreferredWidthForHeightMethodInfo
        ResolveCellRendererToggleMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveCellRendererToggleMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveCellRendererToggleMethod "getRadio" o = CellRendererToggleGetRadioMethodInfo
        ResolveCellRendererToggleMethod "getRequestMode" o = Gtk.CellRenderer.CellRendererGetRequestModeMethodInfo
        ResolveCellRendererToggleMethod "getSensitive" o = Gtk.CellRenderer.CellRendererGetSensitiveMethodInfo
        ResolveCellRendererToggleMethod "getSize" o = Gtk.CellRenderer.CellRendererGetSizeMethodInfo
        ResolveCellRendererToggleMethod "getState" o = Gtk.CellRenderer.CellRendererGetStateMethodInfo
        ResolveCellRendererToggleMethod "getVisible" o = Gtk.CellRenderer.CellRendererGetVisibleMethodInfo
        ResolveCellRendererToggleMethod "setActivatable" o = CellRendererToggleSetActivatableMethodInfo
        ResolveCellRendererToggleMethod "setActive" o = CellRendererToggleSetActiveMethodInfo
        ResolveCellRendererToggleMethod "setAlignment" o = Gtk.CellRenderer.CellRendererSetAlignmentMethodInfo
        ResolveCellRendererToggleMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveCellRendererToggleMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveCellRendererToggleMethod "setFixedSize" o = Gtk.CellRenderer.CellRendererSetFixedSizeMethodInfo
        ResolveCellRendererToggleMethod "setPadding" o = Gtk.CellRenderer.CellRendererSetPaddingMethodInfo
        ResolveCellRendererToggleMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveCellRendererToggleMethod "setRadio" o = CellRendererToggleSetRadioMethodInfo
        ResolveCellRendererToggleMethod "setSensitive" o = Gtk.CellRenderer.CellRendererSetSensitiveMethodInfo
        ResolveCellRendererToggleMethod "setVisible" o = Gtk.CellRenderer.CellRendererSetVisibleMethodInfo
        ResolveCellRendererToggleMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveCellRendererToggleMethod t CellRendererToggle, O.OverloadedMethod info CellRendererToggle p) => OL.IsLabel t (CellRendererToggle -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #if MIN_VERSION_base(4,13,0)
    instance (info ~ ResolveCellRendererToggleMethod t CellRendererToggle, O.OverloadedMethod info CellRendererToggle p, R.HasField t CellRendererToggle p) => R.HasField t CellRendererToggle p where
        getField = O.overloadedMethod @info

    #endif

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

    #endif

    -- signal CellRendererToggle::toggled
    -- | The [toggled](#g:signal:toggled) signal is emitted when the cell is toggled.
    --
    -- It is the responsibility of the application to update the model
    -- with the correct value to store at /@path@/.  Often this is simply the
    -- opposite of the value currently stored at /@path@/.
    type CellRendererToggleToggledCallback =
        T.Text
        -- ^ /@path@/: string representation of t'GI.Gtk.Structs.TreePath.TreePath' describing the
        --        event location
        -> IO ()

    type C_CellRendererToggleToggledCallback =
        Ptr CellRendererToggle ->               -- object
        CString ->
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_CellRendererToggleToggledCallback ::
        GObject a => (a -> CellRendererToggleToggledCallback) ->
        C_CellRendererToggleToggledCallback
    wrap_CellRendererToggleToggledCallback :: forall a.
    GObject a =>
    (a -> CellRendererToggleToggledCallback)
    -> C_CellRendererToggleToggledCallback
    wrap_CellRendererToggleToggledCallback a -> CellRendererToggleToggledCallback
    gi'cb Ptr CellRendererToggle
    gi'selfPtr CString
    path Ptr ()
    _ = do
        path' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    path
        B.ManagedPtr.withNewObject gi'selfPtr $ \CellRendererToggle
    gi'self -> a -> CellRendererToggleToggledCallback
    gi'cb (CellRendererToggle -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce CellRendererToggle
    gi'self)  Text
    path'

    -- | Connect a signal handler for the [toggled](#signal:toggled) 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' cellRendererToggle #toggled callback
    -- @
    --
    --
    onCellRendererToggleToggled :: (IsCellRendererToggle a, MonadIO m) => a -> ((?self :: a) => CellRendererToggleToggledCallback) -> m SignalHandlerId
    onCellRendererToggleToggled :: forall a (m :: * -> *).
    (IsCellRendererToggle a, MonadIO m) =>
    a
    -> ((?self::a) => CellRendererToggleToggledCallback)
    -> m SignalHandlerId
    onCellRendererToggleToggled a
    obj (?self::a) => CellRendererToggleToggledCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> CellRendererToggleToggledCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => CellRendererToggleToggledCallback
    CellRendererToggleToggledCallback
    cb
        let wrapped' :: C_CellRendererToggleToggledCallback
    wrapped' = (a -> CellRendererToggleToggledCallback)
    -> C_CellRendererToggleToggledCallback
    forall a.
    GObject a =>
    (a -> CellRendererToggleToggledCallback)
    -> C_CellRendererToggleToggledCallback
    wrap_CellRendererToggleToggledCallback a -> CellRendererToggleToggledCallback
    wrapped
        wrapped'' <- C_CellRendererToggleToggledCallback
    -> IO (FunPtr C_CellRendererToggleToggledCallback)
    mk_CellRendererToggleToggledCallback C_CellRendererToggleToggledCallback
    wrapped'
        connectSignalFunPtr obj "toggled" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [toggled](#signal:toggled) 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' cellRendererToggle #toggled callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterCellRendererToggleToggled :: (IsCellRendererToggle a, MonadIO m) => a -> ((?self :: a) => CellRendererToggleToggledCallback) -> m SignalHandlerId
    afterCellRendererToggleToggled :: forall a (m :: * -> *).
    (IsCellRendererToggle a, MonadIO m) =>
    a
    -> ((?self::a) => CellRendererToggleToggledCallback)
    -> m SignalHandlerId
    afterCellRendererToggleToggled a
    obj (?self::a) => CellRendererToggleToggledCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> CellRendererToggleToggledCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => CellRendererToggleToggledCallback
    CellRendererToggleToggledCallback
    cb
        let wrapped' :: C_CellRendererToggleToggledCallback
    wrapped' = (a -> CellRendererToggleToggledCallback)
    -> C_CellRendererToggleToggledCallback
    forall a.
    GObject a =>
    (a -> CellRendererToggleToggledCallback)
    -> C_CellRendererToggleToggledCallback
    wrap_CellRendererToggleToggledCallback a -> CellRendererToggleToggledCallback
    wrapped
        wrapped'' <- C_CellRendererToggleToggledCallback
    -> IO (FunPtr C_CellRendererToggleToggledCallback)
    mk_CellRendererToggleToggledCallback C_CellRendererToggleToggledCallback
    wrapped'
        connectSignalFunPtr obj "toggled" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data CellRendererToggleToggledSignalInfo
    instance SignalInfo CellRendererToggleToggledSignalInfo where
        type HaskellCallbackType CellRendererToggleToggledSignalInfo = CellRendererToggleToggledCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_CellRendererToggleToggledCallback cb
            cb'' <- mk_CellRendererToggleToggledCallback cb'
            connectSignalFunPtr obj "toggled" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRendererToggle::toggled"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-CellRendererToggle.html#g:signal:toggled"})

    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data CellRendererToggleActivatablePropertyInfo
    instance AttrInfo CellRendererToggleActivatablePropertyInfo where
        type AttrAllowedOps CellRendererToggleActivatablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint CellRendererToggleActivatablePropertyInfo = IsCellRendererToggle
        type AttrSetTypeConstraint CellRendererToggleActivatablePropertyInfo = (~) Bool
        type AttrTransferTypeConstraint CellRendererToggleActivatablePropertyInfo = (~) Bool
        type AttrTransferType CellRendererToggleActivatablePropertyInfo = Bool
        type AttrGetType CellRendererToggleActivatablePropertyInfo = Bool
        type AttrLabel CellRendererToggleActivatablePropertyInfo = "activatable"
        type AttrOrigin CellRendererToggleActivatablePropertyInfo = CellRendererToggle
        attrGet = getCellRendererToggleActivatable
        attrSet = setCellRendererToggleActivatable
        attrPut = setCellRendererToggleActivatable
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererToggleActivatable
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRendererToggle.activatable"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-CellRendererToggle.html#g:attr:activatable"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data CellRendererToggleActivePropertyInfo
    instance AttrInfo CellRendererToggleActivePropertyInfo where
        type AttrAllowedOps CellRendererToggleActivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint CellRendererToggleActivePropertyInfo = IsCellRendererToggle
        type AttrSetTypeConstraint CellRendererToggleActivePropertyInfo = (~) Bool
        type AttrTransferTypeConstraint CellRendererToggleActivePropertyInfo = (~) Bool
        type AttrTransferType CellRendererToggleActivePropertyInfo = Bool
        type AttrGetType CellRendererToggleActivePropertyInfo = Bool
        type AttrLabel CellRendererToggleActivePropertyInfo = "active"
        type AttrOrigin CellRendererToggleActivePropertyInfo = CellRendererToggle
        attrGet = getCellRendererToggleActive
        attrSet = setCellRendererToggleActive
        attrPut = setCellRendererToggleActive
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererToggleActive
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRendererToggle.active"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-CellRendererToggle.html#g:attr:active"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data CellRendererToggleInconsistentPropertyInfo
    instance AttrInfo CellRendererToggleInconsistentPropertyInfo where
        type AttrAllowedOps CellRendererToggleInconsistentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint CellRendererToggleInconsistentPropertyInfo = IsCellRendererToggle
        type AttrSetTypeConstraint CellRendererToggleInconsistentPropertyInfo = (~) Bool
        type AttrTransferTypeConstraint CellRendererToggleInconsistentPropertyInfo = (~) Bool
        type AttrTransferType CellRendererToggleInconsistentPropertyInfo = Bool
        type AttrGetType CellRendererToggleInconsistentPropertyInfo = Bool
        type AttrLabel CellRendererToggleInconsistentPropertyInfo = "inconsistent"
        type AttrOrigin CellRendererToggleInconsistentPropertyInfo = CellRendererToggle
        attrGet = getCellRendererToggleInconsistent
        attrSet = setCellRendererToggleInconsistent
        attrPut = setCellRendererToggleInconsistent
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererToggleInconsistent
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRendererToggle.inconsistent"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-CellRendererToggle.html#g:attr:inconsistent"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data CellRendererToggleIndicatorSizePropertyInfo
    instance AttrInfo CellRendererToggleIndicatorSizePropertyInfo where
        type AttrAllowedOps CellRendererToggleIndicatorSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint CellRendererToggleIndicatorSizePropertyInfo = IsCellRendererToggle
        type AttrSetTypeConstraint CellRendererToggleIndicatorSizePropertyInfo = (~) Int32
        type AttrTransferTypeConstraint CellRendererToggleIndicatorSizePropertyInfo = (~) Int32
        type AttrTransferType CellRendererToggleIndicatorSizePropertyInfo = Int32
        type AttrGetType CellRendererToggleIndicatorSizePropertyInfo = Int32
        type AttrLabel CellRendererToggleIndicatorSizePropertyInfo = "indicator-size"
        type AttrOrigin CellRendererToggleIndicatorSizePropertyInfo = CellRendererToggle
        attrGet = getCellRendererToggleIndicatorSize
        attrSet = setCellRendererToggleIndicatorSize
        attrPut = setCellRendererToggleIndicatorSize
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererToggleIndicatorSize
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRendererToggle.indicatorSize"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-CellRendererToggle.html#g:attr:indicatorSize"
            })
    #endif

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data CellRendererToggleRadioPropertyInfo
    instance AttrInfo CellRendererToggleRadioPropertyInfo where
        type AttrAllowedOps CellRendererToggleRadioPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint CellRendererToggleRadioPropertyInfo = IsCellRendererToggle
        type AttrSetTypeConstraint CellRendererToggleRadioPropertyInfo = (~) Bool
        type AttrTransferTypeConstraint CellRendererToggleRadioPropertyInfo = (~) Bool
        type AttrTransferType CellRendererToggleRadioPropertyInfo = Bool
        type AttrGetType CellRendererToggleRadioPropertyInfo = Bool
        type AttrLabel CellRendererToggleRadioPropertyInfo = "radio"
        type AttrOrigin CellRendererToggleRadioPropertyInfo = CellRendererToggle
        attrGet = getCellRendererToggleRadio
        attrSet = setCellRendererToggleRadio
        attrPut = setCellRendererToggleRadio
        attrTransfer _ v = do
            return v
        attrConstruct = constructCellRendererToggleRadio
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRendererToggle.radio"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-CellRendererToggle.html#g:attr:radio"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList CellRendererToggle
    type instance O.AttributeList CellRendererToggle = CellRendererToggleAttributeList
    type CellRendererToggleAttributeList = ('[ '("activatable", CellRendererToggleActivatablePropertyInfo), '("active", CellRendererToggleActivePropertyInfo), '("cellBackground", Gtk.CellRenderer.CellRendererCellBackgroundPropertyInfo), '("cellBackgroundGdk", Gtk.CellRenderer.CellRendererCellBackgroundGdkPropertyInfo), '("cellBackgroundRgba", Gtk.CellRenderer.CellRendererCellBackgroundRgbaPropertyInfo), '("cellBackgroundSet", Gtk.CellRenderer.CellRendererCellBackgroundSetPropertyInfo), '("editing", Gtk.CellRenderer.CellRendererEditingPropertyInfo), '("height", Gtk.CellRenderer.CellRendererHeightPropertyInfo), '("inconsistent", CellRendererToggleInconsistentPropertyInfo), '("indicatorSize", CellRendererToggleIndicatorSizePropertyInfo), '("isExpanded", Gtk.CellRenderer.CellRendererIsExpandedPropertyInfo), '("isExpander", Gtk.CellRenderer.CellRendererIsExpanderPropertyInfo), '("mode", Gtk.CellRenderer.CellRendererModePropertyInfo), '("radio", CellRendererToggleRadioPropertyInfo), '("sensitive", Gtk.CellRenderer.CellRendererSensitivePropertyInfo), '("visible", Gtk.CellRenderer.CellRendererVisiblePropertyInfo), '("width", Gtk.CellRenderer.CellRendererWidthPropertyInfo), '("xalign", Gtk.CellRenderer.CellRendererXalignPropertyInfo), '("xpad", Gtk.CellRenderer.CellRendererXpadPropertyInfo), '("yalign", Gtk.CellRenderer.CellRendererYalignPropertyInfo), '("ypad", Gtk.CellRenderer.CellRendererYpadPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    cellRendererToggleActivatable :: AttrLabelProxy "activatable"
    cellRendererToggleActivatable = AttrLabelProxy

    cellRendererToggleActive :: AttrLabelProxy "active"
    cellRendererToggleActive = AttrLabelProxy

    cellRendererToggleInconsistent :: AttrLabelProxy "inconsistent"
    cellRendererToggleInconsistent = AttrLabelProxy

    cellRendererToggleIndicatorSize :: AttrLabelProxy "indicatorSize"
    cellRendererToggleIndicatorSize = AttrLabelProxy

    cellRendererToggleRadio :: AttrLabelProxy "radio"
    cellRendererToggleRadio = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList CellRendererToggle = CellRendererToggleSignalList
    type CellRendererToggleSignalList = ('[ '("editingCanceled", Gtk.CellRenderer.CellRendererEditingCanceledSignalInfo), '("editingStarted", Gtk.CellRenderer.CellRendererEditingStartedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("toggled", CellRendererToggleToggledSignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method CellRendererToggle::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just
    --               (TInterface
    --                  Name { namespace = "Gtk" , name = "CellRendererToggle" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_cell_renderer_toggle_new" gtk_cell_renderer_toggle_new ::
        IO (Ptr CellRendererToggle)

    -- | Creates a new t'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle'. Adjust rendering
    -- parameters using object properties. Object properties can be set
    -- globally (with @/g_object_set()/@). Also, with t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn', you
    -- can bind a property to a value in a t'GI.Gtk.Interfaces.TreeModel.TreeModel'. For example, you
    -- can bind the “active” property on the cell renderer to a boolean value
    -- in the model, thus causing the check button to reflect the state of
    -- the model.
    cellRendererToggleNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m CellRendererToggle
        -- ^ __Returns:__ the new cell renderer
    cellRendererToggleNew :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    m CellRendererToggle
    cellRendererToggleNew  = IO CellRendererToggle -> m CellRendererToggle
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CellRendererToggle -> m CellRendererToggle)
    -> IO CellRendererToggle -> m CellRendererToggle
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr CellRendererToggle)
    gtk_cell_renderer_toggle_new
        checkUnexpectedReturnNULL "cellRendererToggleNew" result
        result' <- (newObject CellRendererToggle) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method CellRendererToggle::get_activatable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "toggle"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRendererToggle" }
    --           , argCType = Just "GtkCellRendererToggle*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRendererToggle"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_cell_renderer_toggle_get_activatable" gtk_cell_renderer_toggle_get_activatable ::
        Ptr CellRendererToggle ->               -- toggle : TInterface (Name {namespace = "Gtk", name = "CellRendererToggle"})
        IO CInt

    -- | Returns whether the cell renderer is activatable. See
    -- 'GI.Gtk.Objects.CellRendererToggle.cellRendererToggleSetActivatable'.
    --
    -- /Since: 2.18/
    cellRendererToggleGetActivatable ::
        (B.CallStack.HasCallStack, MonadIO m, IsCellRendererToggle a) =>
        a
        -- ^ /@toggle@/: a t'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the cell renderer is activatable.
    cellRendererToggleGetActivatable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCellRendererToggle a) =>
    a -> m Bool
    cellRendererToggleGetActivatable a
    toggle = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        toggle' <- a -> IO (Ptr CellRendererToggle)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    toggle
        result <- gtk_cell_renderer_toggle_get_activatable toggle'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr toggle
        return result'

    #if defined(ENABLE_OVERLOADING)
    data CellRendererToggleGetActivatableMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsCellRendererToggle a) => O.OverloadedMethod CellRendererToggleGetActivatableMethodInfo a signature where
        overloadedMethod = cellRendererToggleGetActivatable

    instance O.OverloadedMethodInfo CellRendererToggleGetActivatableMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRendererToggle.cellRendererToggleGetActivatable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-CellRendererToggle.html#v:cellRendererToggleGetActivatable"
            })

    #endif

    -- method CellRendererToggle::get_active
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "toggle"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRendererToggle" }
    --           , argCType = Just "GtkCellRendererToggle*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRendererToggle"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_cell_renderer_toggle_get_active" gtk_cell_renderer_toggle_get_active ::
        Ptr CellRendererToggle ->               -- toggle : TInterface (Name {namespace = "Gtk", name = "CellRendererToggle"})
        IO CInt

    -- | Returns whether the cell renderer is active. See
    -- 'GI.Gtk.Objects.CellRendererToggle.cellRendererToggleSetActive'.
    cellRendererToggleGetActive ::
        (B.CallStack.HasCallStack, MonadIO m, IsCellRendererToggle a) =>
        a
        -- ^ /@toggle@/: a t'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the cell renderer is active.
    cellRendererToggleGetActive :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCellRendererToggle a) =>
    a -> m Bool
    cellRendererToggleGetActive a
    toggle = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        toggle' <- a -> IO (Ptr CellRendererToggle)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    toggle
        result <- gtk_cell_renderer_toggle_get_active toggle'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr toggle
        return result'

    #if defined(ENABLE_OVERLOADING)
    data CellRendererToggleGetActiveMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsCellRendererToggle a) => O.OverloadedMethod CellRendererToggleGetActiveMethodInfo a signature where
        overloadedMethod = cellRendererToggleGetActive

    instance O.OverloadedMethodInfo CellRendererToggleGetActiveMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRendererToggle.cellRendererToggleGetActive",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-CellRendererToggle.html#v:cellRendererToggleGetActive"
            })

    #endif

    -- method CellRendererToggle::get_radio
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "toggle"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRendererToggle" }
    --           , argCType = Just "GtkCellRendererToggle*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRendererToggle"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_cell_renderer_toggle_get_radio" gtk_cell_renderer_toggle_get_radio ::
        Ptr CellRendererToggle ->               -- toggle : TInterface (Name {namespace = "Gtk", name = "CellRendererToggle"})
        IO CInt

    -- | Returns whether we’re rendering radio toggles rather than checkboxes.
    cellRendererToggleGetRadio ::
        (B.CallStack.HasCallStack, MonadIO m, IsCellRendererToggle a) =>
        a
        -- ^ /@toggle@/: a t'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if we’re rendering radio toggles rather than checkboxes
    cellRendererToggleGetRadio :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCellRendererToggle a) =>
    a -> m Bool
    cellRendererToggleGetRadio a
    toggle = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        toggle' <- a -> IO (Ptr CellRendererToggle)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    toggle
        result <- gtk_cell_renderer_toggle_get_radio toggle'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr toggle
        return result'

    #if defined(ENABLE_OVERLOADING)
    data CellRendererToggleGetRadioMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsCellRendererToggle a) => O.OverloadedMethod CellRendererToggleGetRadioMethodInfo a signature where
        overloadedMethod = cellRendererToggleGetRadio

    instance O.OverloadedMethodInfo CellRendererToggleGetRadioMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRendererToggle.cellRendererToggleGetRadio",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-CellRendererToggle.html#v:cellRendererToggleGetRadio"
            })

    #endif

    -- method CellRendererToggle::set_activatable
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "toggle"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRendererToggle" }
    --           , argCType = Just "GtkCellRendererToggle*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRendererToggle."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "setting"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the value to set." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_cell_renderer_toggle_set_activatable" gtk_cell_renderer_toggle_set_activatable ::
        Ptr CellRendererToggle ->               -- toggle : TInterface (Name {namespace = "Gtk", name = "CellRendererToggle"})
        CInt ->                                 -- setting : TBasicType TBoolean
        IO ()

    -- | Makes the cell renderer activatable.
    --
    -- /Since: 2.18/
    cellRendererToggleSetActivatable ::
        (B.CallStack.HasCallStack, MonadIO m, IsCellRendererToggle a) =>
        a
        -- ^ /@toggle@/: a t'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle'.
        -> Bool
        -- ^ /@setting@/: the value to set.
        -> m ()
    cellRendererToggleSetActivatable :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCellRendererToggle a) =>
    a -> Bool -> m ()
    cellRendererToggleSetActivatable a
    toggle Bool
    setting = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        toggle' <- a -> IO (Ptr CellRendererToggle)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    toggle
        let setting' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    setting
        gtk_cell_renderer_toggle_set_activatable toggle' setting'
        touchManagedPtr toggle
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CellRendererToggleSetActivatableMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsCellRendererToggle a) => O.OverloadedMethod CellRendererToggleSetActivatableMethodInfo a signature where
        overloadedMethod = cellRendererToggleSetActivatable

    instance O.OverloadedMethodInfo CellRendererToggleSetActivatableMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRendererToggle.cellRendererToggleSetActivatable",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-CellRendererToggle.html#v:cellRendererToggleSetActivatable"
            })

    #endif

    -- method CellRendererToggle::set_active
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "toggle"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRendererToggle" }
    --           , argCType = Just "GtkCellRendererToggle*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRendererToggle."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "setting"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the value to set." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_cell_renderer_toggle_set_active" gtk_cell_renderer_toggle_set_active ::
        Ptr CellRendererToggle ->               -- toggle : TInterface (Name {namespace = "Gtk", name = "CellRendererToggle"})
        CInt ->                                 -- setting : TBasicType TBoolean
        IO ()

    -- | Activates or deactivates a cell renderer.
    cellRendererToggleSetActive ::
        (B.CallStack.HasCallStack, MonadIO m, IsCellRendererToggle a) =>
        a
        -- ^ /@toggle@/: a t'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle'.
        -> Bool
        -- ^ /@setting@/: the value to set.
        -> m ()
    cellRendererToggleSetActive :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCellRendererToggle a) =>
    a -> Bool -> m ()
    cellRendererToggleSetActive a
    toggle Bool
    setting = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        toggle' <- a -> IO (Ptr CellRendererToggle)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    toggle
        let setting' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    setting
        gtk_cell_renderer_toggle_set_active toggle' setting'
        touchManagedPtr toggle
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CellRendererToggleSetActiveMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsCellRendererToggle a) => O.OverloadedMethod CellRendererToggleSetActiveMethodInfo a signature where
        overloadedMethod = cellRendererToggleSetActive

    instance O.OverloadedMethodInfo CellRendererToggleSetActiveMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRendererToggle.cellRendererToggleSetActive",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-CellRendererToggle.html#v:cellRendererToggleSetActive"
            })

    #endif

    -- method CellRendererToggle::set_radio
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "toggle"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CellRendererToggle" }
    --           , argCType = Just "GtkCellRendererToggle*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCellRendererToggle"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "radio"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "%TRUE to make the toggle look like a radio button"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_cell_renderer_toggle_set_radio" gtk_cell_renderer_toggle_set_radio ::
        Ptr CellRendererToggle ->               -- toggle : TInterface (Name {namespace = "Gtk", name = "CellRendererToggle"})
        CInt ->                                 -- radio : TBasicType TBoolean
        IO ()

    -- | If /@radio@/ is 'P.True', the cell renderer renders a radio toggle
    -- (i.e. a toggle in a group of mutually-exclusive toggles).
    -- If 'P.False', it renders a check toggle (a standalone boolean option).
    -- This can be set globally for the cell renderer, or changed just
    -- before rendering each cell in the model (for t'GI.Gtk.Objects.TreeView.TreeView', you set
    -- up a per-row setting using t'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' to associate model
    -- columns with cell renderer properties).
    cellRendererToggleSetRadio ::
        (B.CallStack.HasCallStack, MonadIO m, IsCellRendererToggle a) =>
        a
        -- ^ /@toggle@/: a t'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle'
        -> Bool
        -- ^ /@radio@/: 'P.True' to make the toggle look like a radio button
        -> m ()
    cellRendererToggleSetRadio :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCellRendererToggle a) =>
    a -> Bool -> m ()
    cellRendererToggleSetRadio a
    toggle Bool
    radio = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        toggle' <- a -> IO (Ptr CellRendererToggle)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    toggle
        let radio' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    radio
        gtk_cell_renderer_toggle_set_radio toggle' radio'
        touchManagedPtr toggle
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CellRendererToggleSetRadioMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsCellRendererToggle a) => O.OverloadedMethod CellRendererToggleSetRadioMethodInfo a signature where
        overloadedMethod = cellRendererToggleSetRadio

    instance O.OverloadedMethodInfo CellRendererToggleSetRadioMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CellRendererToggle.cellRendererToggleSetRadio",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-CellRendererToggle.html#v:cellRendererToggleSetRadio"
            })

    #endif