{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Gtk.Structs.WidgetClass
    ( 

-- * Exported types
    WidgetClass(..)                         ,
    newZeroWidgetClass                      ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addShortcut]("GI.Gtk.Structs.WidgetClass#g:method:addShortcut"), [bindTemplateCallbackFull]("GI.Gtk.Structs.WidgetClass#g:method:bindTemplateCallbackFull"), [bindTemplateChildFull]("GI.Gtk.Structs.WidgetClass#g:method:bindTemplateChildFull"), [installAction]("GI.Gtk.Structs.WidgetClass#g:method:installAction"), [installPropertyAction]("GI.Gtk.Structs.WidgetClass#g:method:installPropertyAction"), [queryAction]("GI.Gtk.Structs.WidgetClass#g:method:queryAction").
-- 
-- ==== Getters
-- [getAccessibleRole]("GI.Gtk.Structs.WidgetClass#g:method:getAccessibleRole"), [getActivateSignal]("GI.Gtk.Structs.WidgetClass#g:method:getActivateSignal"), [getCssName]("GI.Gtk.Structs.WidgetClass#g:method:getCssName"), [getLayoutManagerType]("GI.Gtk.Structs.WidgetClass#g:method:getLayoutManagerType").
-- 
-- ==== Setters
-- [setAccessibleRole]("GI.Gtk.Structs.WidgetClass#g:method:setAccessibleRole"), [setActivateSignal]("GI.Gtk.Structs.WidgetClass#g:method:setActivateSignal"), [setActivateSignalFromName]("GI.Gtk.Structs.WidgetClass#g:method:setActivateSignalFromName"), [setCssName]("GI.Gtk.Structs.WidgetClass#g:method:setCssName"), [setLayoutManagerType]("GI.Gtk.Structs.WidgetClass#g:method:setLayoutManagerType"), [setTemplate]("GI.Gtk.Structs.WidgetClass#g:method:setTemplate"), [setTemplateFromResource]("GI.Gtk.Structs.WidgetClass#g:method:setTemplateFromResource"), [setTemplateScope]("GI.Gtk.Structs.WidgetClass#g:method:setTemplateScope").

#if defined(ENABLE_OVERLOADING)
    ResolveWidgetClassMethod                ,
#endif

-- ** addShortcut #method:addShortcut#

#if defined(ENABLE_OVERLOADING)
    WidgetClassAddShortcutMethodInfo        ,
#endif
    widgetClassAddShortcut                  ,


-- ** bindTemplateCallbackFull #method:bindTemplateCallbackFull#

#if defined(ENABLE_OVERLOADING)
    WidgetClassBindTemplateCallbackFullMethodInfo,
#endif
    widgetClassBindTemplateCallbackFull     ,


-- ** bindTemplateChildFull #method:bindTemplateChildFull#

#if defined(ENABLE_OVERLOADING)
    WidgetClassBindTemplateChildFullMethodInfo,
#endif
    widgetClassBindTemplateChildFull        ,


-- ** getAccessibleRole #method:getAccessibleRole#

#if defined(ENABLE_OVERLOADING)
    WidgetClassGetAccessibleRoleMethodInfo  ,
#endif
    widgetClassGetAccessibleRole            ,


-- ** getActivateSignal #method:getActivateSignal#

#if defined(ENABLE_OVERLOADING)
    WidgetClassGetActivateSignalMethodInfo  ,
#endif
    widgetClassGetActivateSignal            ,


-- ** getCssName #method:getCssName#

#if defined(ENABLE_OVERLOADING)
    WidgetClassGetCssNameMethodInfo         ,
#endif
    widgetClassGetCssName                   ,


-- ** getLayoutManagerType #method:getLayoutManagerType#

#if defined(ENABLE_OVERLOADING)
    WidgetClassGetLayoutManagerTypeMethodInfo,
#endif
    widgetClassGetLayoutManagerType         ,


-- ** installAction #method:installAction#

#if defined(ENABLE_OVERLOADING)
    WidgetClassInstallActionMethodInfo      ,
#endif
    widgetClassInstallAction                ,


-- ** installPropertyAction #method:installPropertyAction#

#if defined(ENABLE_OVERLOADING)
    WidgetClassInstallPropertyActionMethodInfo,
#endif
    widgetClassInstallPropertyAction        ,


-- ** queryAction #method:queryAction#

#if defined(ENABLE_OVERLOADING)
    WidgetClassQueryActionMethodInfo        ,
#endif
    widgetClassQueryAction                  ,


-- ** setAccessibleRole #method:setAccessibleRole#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetAccessibleRoleMethodInfo  ,
#endif
    widgetClassSetAccessibleRole            ,


-- ** setActivateSignal #method:setActivateSignal#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetActivateSignalMethodInfo  ,
#endif
    widgetClassSetActivateSignal            ,


-- ** setActivateSignalFromName #method:setActivateSignalFromName#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetActivateSignalFromNameMethodInfo,
#endif
    widgetClassSetActivateSignalFromName    ,


-- ** setCssName #method:setCssName#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetCssNameMethodInfo         ,
#endif
    widgetClassSetCssName                   ,


-- ** setLayoutManagerType #method:setLayoutManagerType#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetLayoutManagerTypeMethodInfo,
#endif
    widgetClassSetLayoutManagerType         ,


-- ** setTemplate #method:setTemplate#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetTemplateMethodInfo        ,
#endif
    widgetClassSetTemplate                  ,


-- ** setTemplateFromResource #method:setTemplateFromResource#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetTemplateFromResourceMethodInfo,
#endif
    widgetClassSetTemplateFromResource      ,


-- ** setTemplateScope #method:setTemplateScope#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetTemplateScopeMethodInfo   ,
#endif
    widgetClassSetTemplateScope             ,




 -- * Properties


-- ** computeExpand #attr:computeExpand#
-- | Computes whether a container should give this
--   widget extra space when possible.

    clearWidgetClassComputeExpand           ,
    getWidgetClassComputeExpand             ,
    setWidgetClassComputeExpand             ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_computeExpand               ,
#endif


-- ** contains #attr:contains#
-- | Vfunc for 'GI.Gtk.Objects.Widget.widgetContains'.

    clearWidgetClassContains                ,
    getWidgetClassContains                  ,
    setWidgetClassContains                  ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_contains                    ,
#endif


-- ** cssChanged #attr:cssChanged#
-- | Vfunc called when the CSS used by widget was changed. Widgets
--   should then discard their caches that depend on CSS and queue resizes or
--   redraws accordingly. The default implementation will take care of this for
--   all the default CSS properties, so implementations must chain up.

    clearWidgetClassCssChanged              ,
    getWidgetClassCssChanged                ,
    setWidgetClassCssChanged                ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_cssChanged                  ,
#endif


-- ** directionChanged #attr:directionChanged#
-- | Signal emitted when the text direction of a
--   widget changes.

    clearWidgetClassDirectionChanged        ,
    getWidgetClassDirectionChanged          ,
    setWidgetClassDirectionChanged          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_directionChanged            ,
#endif


-- ** focus #attr:focus#
-- | Vfunc for 'GI.Gtk.Objects.Widget.widgetChildFocus'

    clearWidgetClassFocus                   ,
    getWidgetClassFocus                     ,
    setWidgetClassFocus                     ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_focus                       ,
#endif


-- ** getRequestMode #attr:getRequestMode#
-- | Called to get the request mode, if the widget
--   does not have a layout manager.
--   This allows a widget to tell its parent container whether
--   it prefers to be allocated in 'GI.Gtk.Enums.SizeRequestModeHeightForWidth' or
--   'GI.Gtk.Enums.SizeRequestModeWidthForHeight' mode.
--   'GI.Gtk.Enums.SizeRequestModeHeightForWidth' means the widget prefers to have
--   @GtkWidgetClass.measure()@ called first to get the default width (passing
--   a for_size of -1), then again to get the height for said default width.
--   'GI.Gtk.Enums.SizeRequestModeConstantSize' disables any height-for-width or
--   width-for-height geometry management for said widget and is the
--   default return.
--   It’s important to note that any widget
--   which trades height-for-width or width-for-height must respond properly
--   to a for_size value >= -1 passed to @GtkWidgetClass.measure@, for both
--   possible orientations.

    clearWidgetClassGetRequestMode          ,
    getWidgetClassGetRequestMode            ,
    setWidgetClassGetRequestMode            ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_getRequestMode              ,
#endif


-- ** grabFocus #attr:grabFocus#
-- | Causes /@widget@/ to have the keyboard focus for the
--   @GtkWindow@ it’s inside.

    clearWidgetClassGrabFocus               ,
    getWidgetClassGrabFocus                 ,
    setWidgetClassGrabFocus                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_grabFocus                   ,
#endif


-- ** hide #attr:hide#
-- | Signal emitted when widget is hidden.

    clearWidgetClassHide                    ,
    getWidgetClassHide                      ,
    setWidgetClassHide                      ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_hide                        ,
#endif


-- ** keynavFailed #attr:keynavFailed#
-- | Signal emitted if keyboard navigation fails.

    clearWidgetClassKeynavFailed            ,
    getWidgetClassKeynavFailed              ,
    setWidgetClassKeynavFailed              ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_keynavFailed                ,
#endif


-- ** map #attr:map#
-- | Signal emitted when widget is going to be mapped, that is
--   when the widget is visible (which is controlled with
--   'GI.Gtk.Objects.Widget.widgetSetVisible') and all its parents up to the toplevel
--   widget are also visible.

    clearWidgetClassMap                     ,
    getWidgetClassMap                       ,
    setWidgetClassMap                       ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_map                         ,
#endif


-- ** measure #attr:measure#
-- | Called to obtain the minimum and natural size of the widget,
--   if the widget does not have a layout manager.
--   Depending on the orientation parameter, the passed for_size can be
--   interpreted as width or height. A widget will never be allocated less
--   than its minimum size.

    clearWidgetClassMeasure                 ,
    getWidgetClassMeasure                   ,
    setWidgetClassMeasure                   ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_measure                     ,
#endif


-- ** mnemonicActivate #attr:mnemonicActivate#
-- | Activates the /@widget@/ if /@groupCycling@/ is
--   'P.False', and just grabs the focus if /@groupCycling@/ is 'P.True'.

    clearWidgetClassMnemonicActivate        ,
    getWidgetClassMnemonicActivate          ,
    setWidgetClassMnemonicActivate          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_mnemonicActivate            ,
#endif


-- ** moveFocus #attr:moveFocus#
-- | Signal emitted when a change of focus is requested

    clearWidgetClassMoveFocus               ,
    getWidgetClassMoveFocus                 ,
    setWidgetClassMoveFocus                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_moveFocus                   ,
#endif


-- ** parentClass #attr:parentClass#
-- | The object class structure needs to be the first
--   element in the widget class structure in order for the class mechanism
--   to work correctly. This allows a GtkWidgetClass pointer to be cast to
--   a GObjectClass pointer.

    getWidgetClassParentClass               ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_parentClass                 ,
#endif


-- ** queryTooltip #attr:queryTooltip#
-- | Signal emitted when “has-tooltip” is 'P.True' and the
--   hover timeout has expired with the cursor hovering “above”
--   widget; or emitted when widget got focus in keyboard mode.

    clearWidgetClassQueryTooltip            ,
    getWidgetClassQueryTooltip              ,
    setWidgetClassQueryTooltip              ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_queryTooltip                ,
#endif


-- ** realize #attr:realize#
-- | Signal emitted when widget is associated with a
--   @GdkSurface@, which means that 'GI.Gtk.Objects.Widget.widgetRealize' has been called or
--   the widget has been mapped (that is, it is going to be drawn).

    clearWidgetClassRealize                 ,
    getWidgetClassRealize                   ,
    setWidgetClassRealize                   ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_realize                     ,
#endif


-- ** root #attr:root#
-- | Called when the widget gets added to a @GtkRoot@ widget. Must
--   chain up

    clearWidgetClassRoot                    ,
    getWidgetClassRoot                      ,
    setWidgetClassRoot                      ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_root                        ,
#endif


-- ** setFocusChild #attr:setFocusChild#
-- | Sets the focused child of a widget. Must chain up

    clearWidgetClassSetFocusChild           ,
    getWidgetClassSetFocusChild             ,
    setWidgetClassSetFocusChild             ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_setFocusChild               ,
#endif


-- ** show #attr:show#
-- | Signal emitted when widget is shown

    clearWidgetClassShow                    ,
    getWidgetClassShow                      ,
    setWidgetClassShow                      ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_show                        ,
#endif


-- ** sizeAllocate #attr:sizeAllocate#
-- | Called to set the allocation, if the widget does
--   not have a layout manager.

    clearWidgetClassSizeAllocate            ,
    getWidgetClassSizeAllocate              ,
    setWidgetClassSizeAllocate              ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_sizeAllocate                ,
#endif


-- ** snapshot #attr:snapshot#
-- | Vfunc called when a new snapshot of the widget has to be taken.

    clearWidgetClassSnapshot                ,
    getWidgetClassSnapshot                  ,
    setWidgetClassSnapshot                  ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_snapshot                    ,
#endif


-- ** stateFlagsChanged #attr:stateFlagsChanged#
-- | Signal emitted when the widget state changes,
--   see 'GI.Gtk.Objects.Widget.widgetGetStateFlags'.

    clearWidgetClassStateFlagsChanged       ,
    getWidgetClassStateFlagsChanged         ,
    setWidgetClassStateFlagsChanged         ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_stateFlagsChanged           ,
#endif


-- ** systemSettingChanged #attr:systemSettingChanged#
-- | Emitted when a system setting was changed. Must chain up.

    clearWidgetClassSystemSettingChanged    ,
    getWidgetClassSystemSettingChanged      ,
    setWidgetClassSystemSettingChanged      ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_systemSettingChanged        ,
#endif


-- ** unmap #attr:unmap#
-- | Signal emitted when widget is going to be unmapped, which
--   means that either it or any of its parents up to the toplevel
--   widget have been set as hidden.

    clearWidgetClassUnmap                   ,
    getWidgetClassUnmap                     ,
    setWidgetClassUnmap                     ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_unmap                       ,
#endif


-- ** unrealize #attr:unrealize#
-- | Signal emitted when the GdkSurface associated with
--   widget is destroyed, which means that 'GI.Gtk.Objects.Widget.widgetUnrealize' has
--   been called or the widget has been unmapped (that is, it is going
--   to be hidden).

    clearWidgetClassUnrealize               ,
    getWidgetClassUnrealize                 ,
    setWidgetClassUnrealize                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_unrealize                   ,
#endif


-- ** unroot #attr:unroot#
-- | Called when the widget is about to be removed from its
--   @GtkRoot@ widget. Must chain up

    clearWidgetClassUnroot                  ,
    getWidgetClassUnroot                    ,
    setWidgetClassUnroot                    ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_unroot                      ,
#endif




    ) 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.Cairo.Structs.Context as Cairo.Context
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.String as GLib.String
import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.GObject.Structs.InitiallyUnownedClass as GObject.InitiallyUnownedClass
import qualified GI.Gdk.Enums as Gdk.Enums
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
import qualified GI.Gdk.Objects.Clipboard as Gdk.Clipboard
import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
import qualified GI.Gdk.Objects.Device as Gdk.Device
import qualified GI.Gdk.Objects.Display as Gdk.Display
import qualified GI.Gdk.Objects.Event as Gdk.Event
import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
import qualified GI.Gdk.Objects.Snapshot as Gdk.Snapshot
import qualified GI.Gdk.Objects.Surface as Gdk.Surface
import qualified GI.Gdk.Objects.Texture as Gdk.Texture
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
import qualified GI.Graphene.Structs.Point as Graphene.Point
import qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
import qualified GI.Graphene.Structs.Rect as Graphene.Rect
import qualified GI.Graphene.Structs.Size as Graphene.Size
import qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
import qualified GI.Graphene.Structs.Vec4 as Graphene.Vec4
import qualified GI.Gsk.Enums as Gsk.Enums
import qualified GI.Gsk.Objects.GLShader as Gsk.GLShader
import qualified GI.Gsk.Objects.RenderNode as Gsk.RenderNode
import qualified GI.Gsk.Objects.Renderer as Gsk.Renderer
import qualified GI.Gsk.Structs.ColorStop as Gsk.ColorStop
import qualified GI.Gsk.Structs.Path as Gsk.Path
import qualified GI.Gsk.Structs.RoundedRect as Gsk.RoundedRect
import qualified GI.Gsk.Structs.Shadow as Gsk.Shadow
import qualified GI.Gsk.Structs.Stroke as Gsk.Stroke
import qualified GI.Gsk.Structs.Transform as Gsk.Transform
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.Accessible as Gtk.Accessible
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.BuilderScope as Gtk.BuilderScope
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Native as Gtk.Native
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Root as Gtk.Root
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
import {-# SOURCE #-} qualified GI.Gtk.Objects.ATContext as Gtk.ATContext
import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController
import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutChild as Gtk.LayoutChild
import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutManager as Gtk.LayoutManager
import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
import {-# SOURCE #-} qualified GI.Gtk.Objects.Shortcut as Gtk.Shortcut
import {-# SOURCE #-} qualified GI.Gtk.Objects.ShortcutAction as Gtk.ShortcutAction
import {-# SOURCE #-} qualified GI.Gtk.Objects.ShortcutTrigger as Gtk.ShortcutTrigger
import {-# SOURCE #-} qualified GI.Gtk.Objects.Snapshot as Gtk.Snapshot
import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
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.Structs.Border as Gtk.Border
import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
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

#else
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Structs.InitiallyUnownedClass as GObject.InitiallyUnownedClass
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.BuilderScope as Gtk.BuilderScope
import {-# SOURCE #-} qualified GI.Gtk.Objects.Shortcut as Gtk.Shortcut

#endif

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

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

instance BoxedPtr WidgetClass where
    boxedPtrCopy :: WidgetClass -> IO WidgetClass
boxedPtrCopy = \WidgetClass
p -> WidgetClass
-> (Ptr WidgetClass -> IO WidgetClass) -> IO WidgetClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr WidgetClass
p (Int -> Ptr WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
408 (Ptr WidgetClass -> IO (Ptr WidgetClass))
-> (Ptr WidgetClass -> IO WidgetClass)
-> Ptr WidgetClass
-> IO WidgetClass
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr WidgetClass -> WidgetClass)
-> Ptr WidgetClass -> IO WidgetClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr WidgetClass -> WidgetClass
WidgetClass)
    boxedPtrFree :: WidgetClass -> IO ()
boxedPtrFree = \WidgetClass
x -> WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr WidgetClass
x Ptr WidgetClass -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr WidgetClass where
    boxedPtrCalloc :: IO (Ptr WidgetClass)
boxedPtrCalloc = Int -> IO (Ptr WidgetClass)
forall a. Int -> IO (Ptr a)
callocBytes Int
408


-- | Construct a t'WidgetClass' struct initialized to zero.
newZeroWidgetClass :: MonadIO m => m WidgetClass
newZeroWidgetClass :: forall (m :: * -> *). MonadIO m => m WidgetClass
newZeroWidgetClass = IO WidgetClass -> m WidgetClass
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WidgetClass -> m WidgetClass)
-> IO WidgetClass -> m WidgetClass
forall a b. (a -> b) -> a -> b
$ IO (Ptr WidgetClass)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr WidgetClass)
-> (Ptr WidgetClass -> IO WidgetClass) -> IO WidgetClass
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr WidgetClass -> WidgetClass)
-> Ptr WidgetClass -> IO WidgetClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr WidgetClass -> WidgetClass
WidgetClass

instance tag ~ 'AttrSet => Constructible WidgetClass tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr WidgetClass -> WidgetClass)
-> [AttrOp WidgetClass tag] -> m WidgetClass
new ManagedPtr WidgetClass -> WidgetClass
_ [AttrOp WidgetClass tag]
attrs = do
        o <- m WidgetClass
forall (m :: * -> *). MonadIO m => m WidgetClass
newZeroWidgetClass
        GI.Attributes.set o attrs
        return o


-- | Get the value of the “@parent_class@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #parentClass
-- @
getWidgetClassParentClass :: MonadIO m => WidgetClass -> m GObject.InitiallyUnownedClass.InitiallyUnownedClass
getWidgetClassParentClass :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m InitiallyUnownedClass
getWidgetClassParentClass WidgetClass
s = IO InitiallyUnownedClass -> m InitiallyUnownedClass
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InitiallyUnownedClass -> m InitiallyUnownedClass)
-> IO InitiallyUnownedClass -> m InitiallyUnownedClass
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO InitiallyUnownedClass)
-> IO InitiallyUnownedClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO InitiallyUnownedClass)
 -> IO InitiallyUnownedClass)
-> (Ptr WidgetClass -> IO InitiallyUnownedClass)
-> IO InitiallyUnownedClass
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    let val :: Ptr InitiallyUnownedClass
val = Ptr WidgetClass
ptr Ptr WidgetClass -> Int -> Ptr InitiallyUnownedClass
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
    val' <- ((ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass)
-> Ptr InitiallyUnownedClass -> IO InitiallyUnownedClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass
GObject.InitiallyUnownedClass.InitiallyUnownedClass) Ptr InitiallyUnownedClass
val
    return val'

#if defined(ENABLE_OVERLOADING)
data WidgetClassParentClassFieldInfo
instance AttrInfo WidgetClassParentClassFieldInfo where
    type AttrBaseTypeConstraint WidgetClassParentClassFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassParentClassFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WidgetClassParentClassFieldInfo = (~) (Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
    type AttrTransferTypeConstraint WidgetClassParentClassFieldInfo = (~)(Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
    type AttrTransferType WidgetClassParentClassFieldInfo = (Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
    type AttrGetType WidgetClassParentClassFieldInfo = GObject.InitiallyUnownedClass.InitiallyUnownedClass
    type AttrLabel WidgetClassParentClassFieldInfo = "parent_class"
    type AttrOrigin WidgetClassParentClassFieldInfo = WidgetClass
    attrGet = getWidgetClassParentClass
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.parentClass"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:parentClass"
        })

widgetClass_parentClass :: AttrLabelProxy "parentClass"
widgetClass_parentClass = AttrLabelProxy

#endif


-- | Get the value of the “@show@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #show
-- @
getWidgetClassShow :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassShowFieldCallback)
getWidgetClassShow :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassShow WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassShowFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    return result

-- | Set the value of the “@show@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #show 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassShow :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback -> m ()
setWidgetClassShow :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassShow WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)

-- | Set the value of the “@show@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #show
-- @
clearWidgetClassShow :: MonadIO m => WidgetClass -> m ()
clearWidgetClassShow :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassShow WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassShowFieldInfo
instance AttrInfo WidgetClassShowFieldInfo where
    type AttrBaseTypeConstraint WidgetClassShowFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassShowFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassShowFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
    type AttrTransferTypeConstraint WidgetClassShowFieldInfo = (~)Gtk.Callbacks.WidgetClassShowFieldCallback
    type AttrTransferType WidgetClassShowFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
    type AttrGetType WidgetClassShowFieldInfo = Maybe Gtk.Callbacks.WidgetClassShowFieldCallback
    type AttrLabel WidgetClassShowFieldInfo = "show"
    type AttrOrigin WidgetClassShowFieldInfo = WidgetClass
    attrGet = getWidgetClassShow
    attrSet = setWidgetClassShow
    attrConstruct = undefined
    attrClear = clearWidgetClassShow
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassShowFieldCallback (Gtk.Callbacks.wrap_WidgetClassShowFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.show"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:show"
        })

widgetClass_show :: AttrLabelProxy "show"
widgetClass_show = AttrLabelProxy

#endif


-- | Get the value of the “@hide@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #hide
-- @
getWidgetClassHide :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassHideFieldCallback)
getWidgetClassHide :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassHide WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassHideFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    return result

-- | Set the value of the “@hide@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #hide 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassHide :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback -> m ()
setWidgetClassHide :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassHide WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)

-- | Set the value of the “@hide@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #hide
-- @
clearWidgetClassHide :: MonadIO m => WidgetClass -> m ()
clearWidgetClassHide :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassHide WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassHideFieldInfo
instance AttrInfo WidgetClassHideFieldInfo where
    type AttrBaseTypeConstraint WidgetClassHideFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassHideFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassHideFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
    type AttrTransferTypeConstraint WidgetClassHideFieldInfo = (~)Gtk.Callbacks.WidgetClassHideFieldCallback
    type AttrTransferType WidgetClassHideFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
    type AttrGetType WidgetClassHideFieldInfo = Maybe Gtk.Callbacks.WidgetClassHideFieldCallback
    type AttrLabel WidgetClassHideFieldInfo = "hide"
    type AttrOrigin WidgetClassHideFieldInfo = WidgetClass
    attrGet = getWidgetClassHide
    attrSet = setWidgetClassHide
    attrConstruct = undefined
    attrClear = clearWidgetClassHide
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassHideFieldCallback (Gtk.Callbacks.wrap_WidgetClassHideFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.hide"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:hide"
        })

widgetClass_hide :: AttrLabelProxy "hide"
widgetClass_hide = AttrLabelProxy

#endif


-- | Get the value of the “@map@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #map
-- @
getWidgetClassMap :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMapFieldCallback)
getWidgetClassMap :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassMap WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassMapFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    return result

-- | Set the value of the “@map@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #map 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassMap :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback -> m ()
setWidgetClassMap :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassMap WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)

-- | Set the value of the “@map@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #map
-- @
clearWidgetClassMap :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMap :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMap WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassMapFieldInfo
instance AttrInfo WidgetClassMapFieldInfo where
    type AttrBaseTypeConstraint WidgetClassMapFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassMapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassMapFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
    type AttrTransferTypeConstraint WidgetClassMapFieldInfo = (~)Gtk.Callbacks.WidgetClassMapFieldCallback
    type AttrTransferType WidgetClassMapFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
    type AttrGetType WidgetClassMapFieldInfo = Maybe Gtk.Callbacks.WidgetClassMapFieldCallback
    type AttrLabel WidgetClassMapFieldInfo = "map"
    type AttrOrigin WidgetClassMapFieldInfo = WidgetClass
    attrGet = getWidgetClassMap
    attrSet = setWidgetClassMap
    attrConstruct = undefined
    attrClear = clearWidgetClassMap
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassMapFieldCallback (Gtk.Callbacks.wrap_WidgetClassMapFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.map"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:map"
        })

widgetClass_map :: AttrLabelProxy "map"
widgetClass_map = AttrLabelProxy

#endif


-- | Get the value of the “@unmap@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #unmap
-- @
getWidgetClassUnmap :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassUnmapFieldCallback)
getWidgetClassUnmap :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassUnmap WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnmapFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    return result

-- | Set the value of the “@unmap@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #unmap 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassUnmap :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback -> m ()
setWidgetClassUnmap :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassUnmap WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)

-- | Set the value of the “@unmap@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #unmap
-- @
clearWidgetClassUnmap :: MonadIO m => WidgetClass -> m ()
clearWidgetClassUnmap :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassUnmap WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassUnmapFieldInfo
instance AttrInfo WidgetClassUnmapFieldInfo where
    type AttrBaseTypeConstraint WidgetClassUnmapFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassUnmapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassUnmapFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
    type AttrTransferTypeConstraint WidgetClassUnmapFieldInfo = (~)Gtk.Callbacks.WidgetClassUnmapFieldCallback
    type AttrTransferType WidgetClassUnmapFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
    type AttrGetType WidgetClassUnmapFieldInfo = Maybe Gtk.Callbacks.WidgetClassUnmapFieldCallback
    type AttrLabel WidgetClassUnmapFieldInfo = "unmap"
    type AttrOrigin WidgetClassUnmapFieldInfo = WidgetClass
    attrGet = getWidgetClassUnmap
    attrSet = setWidgetClassUnmap
    attrConstruct = undefined
    attrClear = clearWidgetClassUnmap
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassUnmapFieldCallback (Gtk.Callbacks.wrap_WidgetClassUnmapFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.unmap"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:unmap"
        })

widgetClass_unmap :: AttrLabelProxy "unmap"
widgetClass_unmap = AttrLabelProxy

#endif


-- | Get the value of the “@realize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #realize
-- @
getWidgetClassRealize :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassRealizeFieldCallback)
getWidgetClassRealize :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassRealize WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassRealizeFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    return result

-- | Set the value of the “@realize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #realize 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassRealize :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback -> m ()
setWidgetClassRealize :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassRealize WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)

-- | Set the value of the “@realize@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #realize
-- @
clearWidgetClassRealize :: MonadIO m => WidgetClass -> m ()
clearWidgetClassRealize :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassRealize WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassRealizeFieldInfo
instance AttrInfo WidgetClassRealizeFieldInfo where
    type AttrBaseTypeConstraint WidgetClassRealizeFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassRealizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassRealizeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
    type AttrTransferTypeConstraint WidgetClassRealizeFieldInfo = (~)Gtk.Callbacks.WidgetClassRealizeFieldCallback
    type AttrTransferType WidgetClassRealizeFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
    type AttrGetType WidgetClassRealizeFieldInfo = Maybe Gtk.Callbacks.WidgetClassRealizeFieldCallback
    type AttrLabel WidgetClassRealizeFieldInfo = "realize"
    type AttrOrigin WidgetClassRealizeFieldInfo = WidgetClass
    attrGet = getWidgetClassRealize
    attrSet = setWidgetClassRealize
    attrConstruct = undefined
    attrClear = clearWidgetClassRealize
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassRealizeFieldCallback (Gtk.Callbacks.wrap_WidgetClassRealizeFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.realize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:realize"
        })

widgetClass_realize :: AttrLabelProxy "realize"
widgetClass_realize = AttrLabelProxy

#endif


-- | Get the value of the “@unrealize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #unrealize
-- @
getWidgetClassUnrealize :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassUnrealizeFieldCallback)
getWidgetClassUnrealize :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassUnrealize WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnrealizeFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    return result

-- | Set the value of the “@unrealize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #unrealize 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassUnrealize :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback -> m ()
setWidgetClassUnrealize :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassUnrealize WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)

-- | Set the value of the “@unrealize@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #unrealize
-- @
clearWidgetClassUnrealize :: MonadIO m => WidgetClass -> m ()
clearWidgetClassUnrealize :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassUnrealize WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassUnrealizeFieldInfo
instance AttrInfo WidgetClassUnrealizeFieldInfo where
    type AttrBaseTypeConstraint WidgetClassUnrealizeFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassUnrealizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassUnrealizeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
    type AttrTransferTypeConstraint WidgetClassUnrealizeFieldInfo = (~)Gtk.Callbacks.WidgetClassUnrealizeFieldCallback
    type AttrTransferType WidgetClassUnrealizeFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
    type AttrGetType WidgetClassUnrealizeFieldInfo = Maybe Gtk.Callbacks.WidgetClassUnrealizeFieldCallback
    type AttrLabel WidgetClassUnrealizeFieldInfo = "unrealize"
    type AttrOrigin WidgetClassUnrealizeFieldInfo = WidgetClass
    attrGet = getWidgetClassUnrealize
    attrSet = setWidgetClassUnrealize
    attrConstruct = undefined
    attrClear = clearWidgetClassUnrealize
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassUnrealizeFieldCallback (Gtk.Callbacks.wrap_WidgetClassUnrealizeFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.unrealize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:unrealize"
        })

widgetClass_unrealize :: AttrLabelProxy "unrealize"
widgetClass_unrealize = AttrLabelProxy

#endif


-- | Get the value of the “@root@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #root
-- @
getWidgetClassRoot :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassRootFieldCallback)
getWidgetClassRoot :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassRoot WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassRootFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    return result

-- | Set the value of the “@root@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #root 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassRoot :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback -> m ()
setWidgetClassRoot :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassRoot WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)

-- | Set the value of the “@root@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #root
-- @
clearWidgetClassRoot :: MonadIO m => WidgetClass -> m ()
clearWidgetClassRoot :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassRoot WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassRootFieldInfo
instance AttrInfo WidgetClassRootFieldInfo where
    type AttrBaseTypeConstraint WidgetClassRootFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassRootFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassRootFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)
    type AttrTransferTypeConstraint WidgetClassRootFieldInfo = (~)Gtk.Callbacks.WidgetClassRootFieldCallback
    type AttrTransferType WidgetClassRootFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)
    type AttrGetType WidgetClassRootFieldInfo = Maybe Gtk.Callbacks.WidgetClassRootFieldCallback
    type AttrLabel WidgetClassRootFieldInfo = "root"
    type AttrOrigin WidgetClassRootFieldInfo = WidgetClass
    attrGet = getWidgetClassRoot
    attrSet = setWidgetClassRoot
    attrConstruct = undefined
    attrClear = clearWidgetClassRoot
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassRootFieldCallback (Gtk.Callbacks.wrap_WidgetClassRootFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.root"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:root"
        })

widgetClass_root :: AttrLabelProxy "root"
widgetClass_root = AttrLabelProxy

#endif


-- | Get the value of the “@unroot@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #unroot
-- @
getWidgetClassUnroot :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassUnrootFieldCallback)
getWidgetClassUnroot :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassUnroot WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnrootFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    return result

-- | Set the value of the “@unroot@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #unroot 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassUnroot :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback -> m ()
setWidgetClassUnroot :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassUnroot WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)

-- | Set the value of the “@unroot@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #unroot
-- @
clearWidgetClassUnroot :: MonadIO m => WidgetClass -> m ()
clearWidgetClassUnroot :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassUnroot WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassUnrootFieldInfo
instance AttrInfo WidgetClassUnrootFieldInfo where
    type AttrBaseTypeConstraint WidgetClassUnrootFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassUnrootFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassUnrootFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)
    type AttrTransferTypeConstraint WidgetClassUnrootFieldInfo = (~)Gtk.Callbacks.WidgetClassUnrootFieldCallback
    type AttrTransferType WidgetClassUnrootFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)
    type AttrGetType WidgetClassUnrootFieldInfo = Maybe Gtk.Callbacks.WidgetClassUnrootFieldCallback
    type AttrLabel WidgetClassUnrootFieldInfo = "unroot"
    type AttrOrigin WidgetClassUnrootFieldInfo = WidgetClass
    attrGet = getWidgetClassUnroot
    attrSet = setWidgetClassUnroot
    attrConstruct = undefined
    attrClear = clearWidgetClassUnroot
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassUnrootFieldCallback (Gtk.Callbacks.wrap_WidgetClassUnrootFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.unroot"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:unroot"
        })

widgetClass_unroot :: AttrLabelProxy "unroot"
widgetClass_unroot = AttrLabelProxy

#endif


-- | Get the value of the “@size_allocate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #sizeAllocate
-- @
getWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSizeAllocateFieldCallback)
getWidgetClassSizeAllocate :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassSizeAllocateFieldCallback)
getWidgetClassSizeAllocate WidgetClass
s = IO (Maybe WidgetClassSizeAllocateFieldCallback)
-> m (Maybe WidgetClassSizeAllocateFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassSizeAllocateFieldCallback)
 -> m (Maybe WidgetClassSizeAllocateFieldCallback))
-> IO (Maybe WidgetClassSizeAllocateFieldCallback)
-> m (Maybe WidgetClassSizeAllocateFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
-> IO (Maybe WidgetClassSizeAllocateFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
 -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
-> IO (Maybe WidgetClassSizeAllocateFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
-> IO (FunPtr C_WidgetClassSizeAllocateFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassSizeAllocateFieldCallback
val' -> do
        let val'' :: WidgetClassSizeAllocateFieldCallback
val'' = FunPtr C_WidgetClassSizeAllocateFieldCallback
-> WidgetClassSizeAllocateFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassSizeAllocateFieldCallback
-> a -> Int32 -> Int32 -> Int32 -> m ()
Gtk.Callbacks.dynamic_WidgetClassSizeAllocateFieldCallback FunPtr C_WidgetClassSizeAllocateFieldCallback
val'
        WidgetClassSizeAllocateFieldCallback
-> IO WidgetClassSizeAllocateFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSizeAllocateFieldCallback
val''
    return result

-- | Set the value of the “@size_allocate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #sizeAllocate 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback -> m ()
setWidgetClassSizeAllocate :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassSizeAllocateFieldCallback -> m ()
setWidgetClassSizeAllocate WidgetClass
s FunPtr C_WidgetClassSizeAllocateFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
-> FunPtr C_WidgetClassSizeAllocateFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_WidgetClassSizeAllocateFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)

-- | Set the value of the “@size_allocate@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #sizeAllocate
-- @
clearWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSizeAllocate :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSizeAllocate WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
-> FunPtr C_WidgetClassSizeAllocateFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_WidgetClassSizeAllocateFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSizeAllocateFieldInfo
instance AttrInfo WidgetClassSizeAllocateFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSizeAllocateFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSizeAllocateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSizeAllocateFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSizeAllocateFieldInfo = (~)Gtk.Callbacks.WidgetClassSizeAllocateFieldCallback
    type AttrTransferType WidgetClassSizeAllocateFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)
    type AttrGetType WidgetClassSizeAllocateFieldInfo = Maybe Gtk.Callbacks.WidgetClassSizeAllocateFieldCallback
    type AttrLabel WidgetClassSizeAllocateFieldInfo = "size_allocate"
    type AttrOrigin WidgetClassSizeAllocateFieldInfo = WidgetClass
    attrGet = getWidgetClassSizeAllocate
    attrSet = setWidgetClassSizeAllocate
    attrConstruct = undefined
    attrClear = clearWidgetClassSizeAllocate
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSizeAllocateFieldCallback (Gtk.Callbacks.wrap_WidgetClassSizeAllocateFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.sizeAllocate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:sizeAllocate"
        })

widgetClass_sizeAllocate :: AttrLabelProxy "sizeAllocate"
widgetClass_sizeAllocate = AttrLabelProxy

#endif


-- | Get the value of the “@state_flags_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #stateFlagsChanged
-- @
getWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassStateFlagsChangedFieldCallback)
getWidgetClassStateFlagsChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
getWidgetClassStateFlagsChanged WidgetClass
s = IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
-> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
 -> m (Maybe WidgetClassStateFlagsChangedFieldCallback))
-> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
-> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
-> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
 -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
-> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val' -> do
        let val'' :: WidgetClassStateFlagsChangedFieldCallback
val'' = FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> WidgetClassStateFlagsChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> a -> [StateFlags] -> m ()
Gtk.Callbacks.dynamic_WidgetClassStateFlagsChangedFieldCallback FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val'
        WidgetClassStateFlagsChangedFieldCallback
-> IO WidgetClassStateFlagsChangedFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassStateFlagsChangedFieldCallback
val''
    return result

-- | Set the value of the “@state_flags_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #stateFlagsChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassStateFlagsChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassStateFlagsChanged WidgetClass
s FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)

-- | Set the value of the “@state_flags_changed@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #stateFlagsChanged
-- @
clearWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassStateFlagsChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassStateFlagsChanged WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassStateFlagsChangedFieldInfo
instance AttrInfo WidgetClassStateFlagsChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassStateFlagsChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassStateFlagsChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassStateFlagsChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassStateFlagsChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassStateFlagsChangedFieldCallback
    type AttrTransferType WidgetClassStateFlagsChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)
    type AttrGetType WidgetClassStateFlagsChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassStateFlagsChangedFieldCallback
    type AttrLabel WidgetClassStateFlagsChangedFieldInfo = "state_flags_changed"
    type AttrOrigin WidgetClassStateFlagsChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassStateFlagsChanged
    attrSet = setWidgetClassStateFlagsChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassStateFlagsChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassStateFlagsChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassStateFlagsChangedFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.stateFlagsChanged"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:stateFlagsChanged"
        })

widgetClass_stateFlagsChanged :: AttrLabelProxy "stateFlagsChanged"
widgetClass_stateFlagsChanged = AttrLabelProxy

#endif


-- | Get the value of the “@direction_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #directionChanged
-- @
getWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDirectionChangedFieldCallback)
getWidgetClassDirectionChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDirectionChangedFieldCallback)
getWidgetClassDirectionChanged WidgetClass
s = IO (Maybe WidgetClassDirectionChangedFieldCallback)
-> m (Maybe WidgetClassDirectionChangedFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDirectionChangedFieldCallback)
 -> m (Maybe WidgetClassDirectionChangedFieldCallback))
-> IO (Maybe WidgetClassDirectionChangedFieldCallback)
-> m (Maybe WidgetClassDirectionChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
-> IO (Maybe WidgetClassDirectionChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
 -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
-> IO (Maybe WidgetClassDirectionChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
216) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val' -> do
        let val'' :: WidgetClassDirectionChangedFieldCallback
val'' = FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> WidgetClassDirectionChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> a -> TextDirection -> m ()
Gtk.Callbacks.dynamic_WidgetClassDirectionChangedFieldCallback FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val'
        WidgetClassDirectionChangedFieldCallback
-> IO WidgetClassDirectionChangedFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDirectionChangedFieldCallback
val''
    return result

-- | Set the value of the “@direction_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #directionChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback -> m ()
setWidgetClassDirectionChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassDirectionChanged WidgetClass
s FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
216) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)

-- | Set the value of the “@direction_changed@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #directionChanged
-- @
clearWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDirectionChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDirectionChanged WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
216) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDirectionChangedFieldInfo
instance AttrInfo WidgetClassDirectionChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDirectionChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDirectionChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDirectionChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDirectionChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassDirectionChangedFieldCallback
    type AttrTransferType WidgetClassDirectionChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)
    type AttrGetType WidgetClassDirectionChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassDirectionChangedFieldCallback
    type AttrLabel WidgetClassDirectionChangedFieldInfo = "direction_changed"
    type AttrOrigin WidgetClassDirectionChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassDirectionChanged
    attrSet = setWidgetClassDirectionChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassDirectionChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDirectionChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassDirectionChangedFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.directionChanged"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:directionChanged"
        })

widgetClass_directionChanged :: AttrLabelProxy "directionChanged"
widgetClass_directionChanged = AttrLabelProxy

#endif


-- | Get the value of the “@get_request_mode@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #getRequestMode
-- @
getWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGetRequestModeFieldCallback)
getWidgetClassGetRequestMode :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassGetRequestModeFieldCallback)
getWidgetClassGetRequestMode WidgetClass
s = IO (Maybe WidgetClassGetRequestModeFieldCallback)
-> m (Maybe WidgetClassGetRequestModeFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassGetRequestModeFieldCallback)
 -> m (Maybe WidgetClassGetRequestModeFieldCallback))
-> IO (Maybe WidgetClassGetRequestModeFieldCallback)
-> m (Maybe WidgetClassGetRequestModeFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
-> IO (Maybe WidgetClassGetRequestModeFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
 -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
-> IO (Maybe WidgetClassGetRequestModeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
-> IO (FunPtr C_WidgetClassGetRequestModeFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
224) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassGetRequestModeFieldCallback
val' -> do
        let val'' :: WidgetClassGetRequestModeFieldCallback
val'' = FunPtr C_WidgetClassGetRequestModeFieldCallback
-> WidgetClassGetRequestModeFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGetRequestModeFieldCallback
-> a -> m SizeRequestMode
Gtk.Callbacks.dynamic_WidgetClassGetRequestModeFieldCallback FunPtr C_WidgetClassGetRequestModeFieldCallback
val'
        WidgetClassGetRequestModeFieldCallback
-> IO WidgetClassGetRequestModeFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGetRequestModeFieldCallback
val''
    return result

-- | Set the value of the “@get_request_mode@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #getRequestMode 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback -> m ()
setWidgetClassGetRequestMode :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassGetRequestModeFieldCallback -> m ()
setWidgetClassGetRequestMode WidgetClass
s FunPtr C_WidgetClassGetRequestModeFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
-> FunPtr C_WidgetClassGetRequestModeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
224) (FunPtr C_WidgetClassGetRequestModeFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)

-- | Set the value of the “@get_request_mode@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #getRequestMode
-- @
clearWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetRequestMode :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGetRequestMode WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
-> FunPtr C_WidgetClassGetRequestModeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
224) (FunPtr C_WidgetClassGetRequestModeFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetRequestModeFieldInfo
instance AttrInfo WidgetClassGetRequestModeFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGetRequestModeFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGetRequestModeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGetRequestModeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGetRequestModeFieldInfo = (~)Gtk.Callbacks.WidgetClassGetRequestModeFieldCallback
    type AttrTransferType WidgetClassGetRequestModeFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)
    type AttrGetType WidgetClassGetRequestModeFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetRequestModeFieldCallback
    type AttrLabel WidgetClassGetRequestModeFieldInfo = "get_request_mode"
    type AttrOrigin WidgetClassGetRequestModeFieldInfo = WidgetClass
    attrGet = getWidgetClassGetRequestMode
    attrSet = setWidgetClassGetRequestMode
    attrConstruct = undefined
    attrClear = clearWidgetClassGetRequestMode
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGetRequestModeFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetRequestModeFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.getRequestMode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:getRequestMode"
        })

widgetClass_getRequestMode :: AttrLabelProxy "getRequestMode"
widgetClass_getRequestMode = AttrLabelProxy

#endif


-- | Get the value of the “@measure@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #measure
-- @
getWidgetClassMeasure :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMeasureFieldCallback)
getWidgetClassMeasure :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassMeasureFieldCallback)
getWidgetClassMeasure WidgetClass
s = IO (Maybe WidgetClassMeasureFieldCallback)
-> m (Maybe WidgetClassMeasureFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassMeasureFieldCallback)
 -> m (Maybe WidgetClassMeasureFieldCallback))
-> IO (Maybe WidgetClassMeasureFieldCallback)
-> m (Maybe WidgetClassMeasureFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassMeasureFieldCallback))
-> IO (Maybe WidgetClassMeasureFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassMeasureFieldCallback))
 -> IO (Maybe WidgetClassMeasureFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassMeasureFieldCallback))
-> IO (Maybe WidgetClassMeasureFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
-> IO (FunPtr C_WidgetClassMeasureFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassMeasureFieldCallback
val' -> do
        let val'' :: WidgetClassMeasureFieldCallback
val'' = FunPtr C_WidgetClassMeasureFieldCallback
-> WidgetClassMeasureFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassMeasureFieldCallback
-> a -> Orientation -> Int32 -> m (Int32, Int32, Int32, Int32)
Gtk.Callbacks.dynamic_WidgetClassMeasureFieldCallback FunPtr C_WidgetClassMeasureFieldCallback
val'
        WidgetClassMeasureFieldCallback
-> IO WidgetClassMeasureFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassMeasureFieldCallback
val''
    return result

-- | Set the value of the “@measure@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #measure 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassMeasure :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback -> m ()
setWidgetClassMeasure :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassMeasureFieldCallback -> m ()
setWidgetClassMeasure WidgetClass
s FunPtr C_WidgetClassMeasureFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
-> FunPtr C_WidgetClassMeasureFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) (FunPtr C_WidgetClassMeasureFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)

-- | Set the value of the “@measure@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #measure
-- @
clearWidgetClassMeasure :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMeasure :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMeasure WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
-> FunPtr C_WidgetClassMeasureFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) (FunPtr C_WidgetClassMeasureFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassMeasureFieldInfo
instance AttrInfo WidgetClassMeasureFieldInfo where
    type AttrBaseTypeConstraint WidgetClassMeasureFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassMeasureFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassMeasureFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)
    type AttrTransferTypeConstraint WidgetClassMeasureFieldInfo = (~)Gtk.Callbacks.WidgetClassMeasureFieldCallback
    type AttrTransferType WidgetClassMeasureFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)
    type AttrGetType WidgetClassMeasureFieldInfo = Maybe Gtk.Callbacks.WidgetClassMeasureFieldCallback
    type AttrLabel WidgetClassMeasureFieldInfo = "measure"
    type AttrOrigin WidgetClassMeasureFieldInfo = WidgetClass
    attrGet = getWidgetClassMeasure
    attrSet = setWidgetClassMeasure
    attrConstruct = undefined
    attrClear = clearWidgetClassMeasure
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassMeasureFieldCallback (Gtk.Callbacks.wrap_WidgetClassMeasureFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.measure"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:measure"
        })

widgetClass_measure :: AttrLabelProxy "measure"
widgetClass_measure = AttrLabelProxy

#endif


-- | Get the value of the “@mnemonic_activate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #mnemonicActivate
-- @
getWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMnemonicActivateFieldCallback)
getWidgetClassMnemonicActivate :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassMnemonicActivateFieldCallback)
getWidgetClassMnemonicActivate WidgetClass
s = IO (Maybe WidgetClassMnemonicActivateFieldCallback)
-> m (Maybe WidgetClassMnemonicActivateFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassMnemonicActivateFieldCallback)
 -> m (Maybe WidgetClassMnemonicActivateFieldCallback))
-> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
-> m (Maybe WidgetClassMnemonicActivateFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
-> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
 -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
-> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
-> IO (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassMnemonicActivateFieldCallback
val' -> do
        let val'' :: WidgetClassMnemonicActivateFieldCallback
val'' = FunPtr C_WidgetClassMnemonicActivateFieldCallback
-> WidgetClassMnemonicActivateFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassMnemonicActivateFieldCallback
-> a -> Bool -> m Bool
Gtk.Callbacks.dynamic_WidgetClassMnemonicActivateFieldCallback FunPtr C_WidgetClassMnemonicActivateFieldCallback
val'
        WidgetClassMnemonicActivateFieldCallback
-> IO WidgetClassMnemonicActivateFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassMnemonicActivateFieldCallback
val''
    return result

-- | Set the value of the “@mnemonic_activate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #mnemonicActivate 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback -> m ()
setWidgetClassMnemonicActivate :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> m ()
setWidgetClassMnemonicActivate WidgetClass
s FunPtr C_WidgetClassMnemonicActivateFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
-> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) (FunPtr C_WidgetClassMnemonicActivateFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)

-- | Set the value of the “@mnemonic_activate@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #mnemonicActivate
-- @
clearWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMnemonicActivate :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMnemonicActivate WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
-> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) (FunPtr C_WidgetClassMnemonicActivateFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassMnemonicActivateFieldInfo
instance AttrInfo WidgetClassMnemonicActivateFieldInfo where
    type AttrBaseTypeConstraint WidgetClassMnemonicActivateFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassMnemonicActivateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassMnemonicActivateFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)
    type AttrTransferTypeConstraint WidgetClassMnemonicActivateFieldInfo = (~)Gtk.Callbacks.WidgetClassMnemonicActivateFieldCallback
    type AttrTransferType WidgetClassMnemonicActivateFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)
    type AttrGetType WidgetClassMnemonicActivateFieldInfo = Maybe Gtk.Callbacks.WidgetClassMnemonicActivateFieldCallback
    type AttrLabel WidgetClassMnemonicActivateFieldInfo = "mnemonic_activate"
    type AttrOrigin WidgetClassMnemonicActivateFieldInfo = WidgetClass
    attrGet = getWidgetClassMnemonicActivate
    attrSet = setWidgetClassMnemonicActivate
    attrConstruct = undefined
    attrClear = clearWidgetClassMnemonicActivate
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassMnemonicActivateFieldCallback (Gtk.Callbacks.wrap_WidgetClassMnemonicActivateFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.mnemonicActivate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:mnemonicActivate"
        })

widgetClass_mnemonicActivate :: AttrLabelProxy "mnemonicActivate"
widgetClass_mnemonicActivate = AttrLabelProxy

#endif


-- | Get the value of the “@grab_focus@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #grabFocus
-- @
getWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGrabFocusFieldCallback)
getWidgetClassGrabFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassGrabFocusFieldCallback)
getWidgetClassGrabFocus WidgetClass
s = IO (Maybe WidgetClassGrabFocusFieldCallback)
-> m (Maybe WidgetClassGrabFocusFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassGrabFocusFieldCallback)
 -> m (Maybe WidgetClassGrabFocusFieldCallback))
-> IO (Maybe WidgetClassGrabFocusFieldCallback)
-> m (Maybe WidgetClassGrabFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassGrabFocusFieldCallback))
-> IO (Maybe WidgetClassGrabFocusFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassGrabFocusFieldCallback))
 -> IO (Maybe WidgetClassGrabFocusFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassGrabFocusFieldCallback))
-> IO (Maybe WidgetClassGrabFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
-> IO (FunPtr C_WidgetClassGrabFocusFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassGrabFocusFieldCallback
val' -> do
        let val'' :: WidgetClassGrabFocusFieldCallback
val'' = FunPtr C_WidgetClassGrabFocusFieldCallback
-> WidgetClassGrabFocusFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGrabFocusFieldCallback -> a -> m Bool
Gtk.Callbacks.dynamic_WidgetClassGrabFocusFieldCallback FunPtr C_WidgetClassGrabFocusFieldCallback
val'
        WidgetClassGrabFocusFieldCallback
-> IO WidgetClassGrabFocusFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGrabFocusFieldCallback
val''
    return result

-- | Set the value of the “@grab_focus@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #grabFocus 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGrabFocus :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback -> m ()
setWidgetClassGrabFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassGrabFocusFieldCallback -> m ()
setWidgetClassGrabFocus WidgetClass
s FunPtr C_WidgetClassGrabFocusFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
-> FunPtr C_WidgetClassGrabFocusFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) (FunPtr C_WidgetClassGrabFocusFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)

-- | Set the value of the “@grab_focus@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #grabFocus
-- @
clearWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabFocus :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabFocus WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
-> FunPtr C_WidgetClassGrabFocusFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) (FunPtr C_WidgetClassGrabFocusFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGrabFocusFieldInfo
instance AttrInfo WidgetClassGrabFocusFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGrabFocusFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGrabFocusFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGrabFocusFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGrabFocusFieldInfo = (~)Gtk.Callbacks.WidgetClassGrabFocusFieldCallback
    type AttrTransferType WidgetClassGrabFocusFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
    type AttrGetType WidgetClassGrabFocusFieldInfo = Maybe Gtk.Callbacks.WidgetClassGrabFocusFieldCallback
    type AttrLabel WidgetClassGrabFocusFieldInfo = "grab_focus"
    type AttrOrigin WidgetClassGrabFocusFieldInfo = WidgetClass
    attrGet = getWidgetClassGrabFocus
    attrSet = setWidgetClassGrabFocus
    attrConstruct = undefined
    attrClear = clearWidgetClassGrabFocus
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGrabFocusFieldCallback (Gtk.Callbacks.wrap_WidgetClassGrabFocusFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.grabFocus"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:grabFocus"
        })

widgetClass_grabFocus :: AttrLabelProxy "grabFocus"
widgetClass_grabFocus = AttrLabelProxy

#endif


-- | Get the value of the “@focus@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #focus
-- @
getWidgetClassFocus :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassFocusFieldCallback)
getWidgetClassFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)
getWidgetClassFocus WidgetClass
s = IO (Maybe WidgetClassFocusFieldCallback)
-> m (Maybe WidgetClassFocusFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassFocusFieldCallback)
 -> m (Maybe WidgetClassFocusFieldCallback))
-> IO (Maybe WidgetClassFocusFieldCallback)
-> m (Maybe WidgetClassFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
 -> IO (Maybe WidgetClassFocusFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassFocusFieldCallback)
-> IO (FunPtr C_WidgetClassFocusFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassFocusFieldCallback
val' -> do
        let val'' :: WidgetClassFocusFieldCallback
val'' = FunPtr C_WidgetClassFocusFieldCallback
-> WidgetClassFocusFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassFocusFieldCallback
-> a -> DirectionType -> m Bool
Gtk.Callbacks.dynamic_WidgetClassFocusFieldCallback FunPtr C_WidgetClassFocusFieldCallback
val'
        WidgetClassFocusFieldCallback -> IO WidgetClassFocusFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassFocusFieldCallback
val''
    return result

-- | Set the value of the “@focus@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #focus 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassFocus :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassFocus WidgetClass
s FunPtr C_WidgetClassFocusFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassFocusFieldCallback)
-> FunPtr C_WidgetClassFocusFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) (FunPtr C_WidgetClassFocusFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)

-- | Set the value of the “@focus@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #focus
-- @
clearWidgetClassFocus :: MonadIO m => WidgetClass -> m ()
clearWidgetClassFocus :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassFocus WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassFocusFieldCallback)
-> FunPtr C_WidgetClassFocusFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) (FunPtr C_WidgetClassFocusFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassFocusFieldInfo
instance AttrInfo WidgetClassFocusFieldInfo where
    type AttrBaseTypeConstraint WidgetClassFocusFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassFocusFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassFocusFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)
    type AttrTransferTypeConstraint WidgetClassFocusFieldInfo = (~)Gtk.Callbacks.WidgetClassFocusFieldCallback
    type AttrTransferType WidgetClassFocusFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)
    type AttrGetType WidgetClassFocusFieldInfo = Maybe Gtk.Callbacks.WidgetClassFocusFieldCallback
    type AttrLabel WidgetClassFocusFieldInfo = "focus"
    type AttrOrigin WidgetClassFocusFieldInfo = WidgetClass
    attrGet = getWidgetClassFocus
    attrSet = setWidgetClassFocus
    attrConstruct = undefined
    attrClear = clearWidgetClassFocus
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassFocusFieldCallback (Gtk.Callbacks.wrap_WidgetClassFocusFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.focus"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:focus"
        })

widgetClass_focus :: AttrLabelProxy "focus"
widgetClass_focus = AttrLabelProxy

#endif


-- | Get the value of the “@set_focus_child@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #setFocusChild
-- @
getWidgetClassSetFocusChild :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSetFocusChildFieldCallback)
getWidgetClassSetFocusChild :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassSetFocusChildFieldCallback)
getWidgetClassSetFocusChild WidgetClass
s = IO (Maybe WidgetClassSetFocusChildFieldCallback)
-> m (Maybe WidgetClassSetFocusChildFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassSetFocusChildFieldCallback)
 -> m (Maybe WidgetClassSetFocusChildFieldCallback))
-> IO (Maybe WidgetClassSetFocusChildFieldCallback)
-> m (Maybe WidgetClassSetFocusChildFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
-> IO (Maybe WidgetClassSetFocusChildFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
 -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
-> IO (Maybe WidgetClassSetFocusChildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
-> IO (FunPtr C_WidgetClassSetFocusChildFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassSetFocusChildFieldCallback
val' -> do
        let val'' :: WidgetClassSetFocusChildFieldCallback
val'' = FunPtr C_WidgetClassSetFocusChildFieldCallback
-> WidgetClassSetFocusChildFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
FunPtr C_WidgetClassSetFocusChildFieldCallback
-> a -> Maybe b -> m ()
Gtk.Callbacks.dynamic_WidgetClassSetFocusChildFieldCallback FunPtr C_WidgetClassSetFocusChildFieldCallback
val'
        WidgetClassSetFocusChildFieldCallback
-> IO WidgetClassSetFocusChildFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSetFocusChildFieldCallback
val''
    return result

-- | Set the value of the “@set_focus_child@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #setFocusChild 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSetFocusChild :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback -> m ()
setWidgetClassSetFocusChild :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassSetFocusChildFieldCallback -> m ()
setWidgetClassSetFocusChild WidgetClass
s FunPtr C_WidgetClassSetFocusChildFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
-> FunPtr C_WidgetClassSetFocusChildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) (FunPtr C_WidgetClassSetFocusChildFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)

-- | Set the value of the “@set_focus_child@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #setFocusChild
-- @
clearWidgetClassSetFocusChild :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSetFocusChild :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSetFocusChild WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
-> FunPtr C_WidgetClassSetFocusChildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) (FunPtr C_WidgetClassSetFocusChildFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetFocusChildFieldInfo
instance AttrInfo WidgetClassSetFocusChildFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSetFocusChildFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSetFocusChildFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSetFocusChildFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSetFocusChildFieldInfo = (~)Gtk.Callbacks.WidgetClassSetFocusChildFieldCallback
    type AttrTransferType WidgetClassSetFocusChildFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)
    type AttrGetType WidgetClassSetFocusChildFieldInfo = Maybe Gtk.Callbacks.WidgetClassSetFocusChildFieldCallback
    type AttrLabel WidgetClassSetFocusChildFieldInfo = "set_focus_child"
    type AttrOrigin WidgetClassSetFocusChildFieldInfo = WidgetClass
    attrGet = getWidgetClassSetFocusChild
    attrSet = setWidgetClassSetFocusChild
    attrConstruct = undefined
    attrClear = clearWidgetClassSetFocusChild
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSetFocusChildFieldCallback (Gtk.Callbacks.wrap_WidgetClassSetFocusChildFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.setFocusChild"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:setFocusChild"
        })

widgetClass_setFocusChild :: AttrLabelProxy "setFocusChild"
widgetClass_setFocusChild = AttrLabelProxy

#endif


-- | Get the value of the “@move_focus@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #moveFocus
-- @
getWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMoveFocusFieldCallback)
getWidgetClassMoveFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassMoveFocusFieldCallback)
getWidgetClassMoveFocus WidgetClass
s = IO (Maybe WidgetClassMoveFocusFieldCallback)
-> m (Maybe WidgetClassMoveFocusFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassMoveFocusFieldCallback)
 -> m (Maybe WidgetClassMoveFocusFieldCallback))
-> IO (Maybe WidgetClassMoveFocusFieldCallback)
-> m (Maybe WidgetClassMoveFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassMoveFocusFieldCallback))
-> IO (Maybe WidgetClassMoveFocusFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassMoveFocusFieldCallback))
 -> IO (Maybe WidgetClassMoveFocusFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassMoveFocusFieldCallback))
-> IO (Maybe WidgetClassMoveFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val' -> do
        let val'' :: WidgetClassMoveFocusFieldCallback
val'' = FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> WidgetClassMoveFocusFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> a -> DirectionType -> m ()
Gtk.Callbacks.dynamic_WidgetClassMoveFocusFieldCallback FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val'
        WidgetClassMoveFocusFieldCallback
-> IO WidgetClassMoveFocusFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassMoveFocusFieldCallback
val''
    return result

-- | Set the value of the “@move_focus@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #moveFocus 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassMoveFocus :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback -> m ()
setWidgetClassMoveFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassMoveFocus WidgetClass
s FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)

-- | Set the value of the “@move_focus@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #moveFocus
-- @
clearWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMoveFocus :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMoveFocus WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassMoveFocusFieldInfo
instance AttrInfo WidgetClassMoveFocusFieldInfo where
    type AttrBaseTypeConstraint WidgetClassMoveFocusFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassMoveFocusFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassMoveFocusFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)
    type AttrTransferTypeConstraint WidgetClassMoveFocusFieldInfo = (~)Gtk.Callbacks.WidgetClassMoveFocusFieldCallback
    type AttrTransferType WidgetClassMoveFocusFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)
    type AttrGetType WidgetClassMoveFocusFieldInfo = Maybe Gtk.Callbacks.WidgetClassMoveFocusFieldCallback
    type AttrLabel WidgetClassMoveFocusFieldInfo = "move_focus"
    type AttrOrigin WidgetClassMoveFocusFieldInfo = WidgetClass
    attrGet = getWidgetClassMoveFocus
    attrSet = setWidgetClassMoveFocus
    attrConstruct = undefined
    attrClear = clearWidgetClassMoveFocus
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassMoveFocusFieldCallback (Gtk.Callbacks.wrap_WidgetClassMoveFocusFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.moveFocus"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:moveFocus"
        })

widgetClass_moveFocus :: AttrLabelProxy "moveFocus"
widgetClass_moveFocus = AttrLabelProxy

#endif


-- | Get the value of the “@keynav_failed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #keynavFailed
-- @
getWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassKeynavFailedFieldCallback)
getWidgetClassKeynavFailed :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)
getWidgetClassKeynavFailed WidgetClass
s = IO (Maybe WidgetClassFocusFieldCallback)
-> m (Maybe WidgetClassFocusFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassFocusFieldCallback)
 -> m (Maybe WidgetClassFocusFieldCallback))
-> IO (Maybe WidgetClassFocusFieldCallback)
-> m (Maybe WidgetClassFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
 -> IO (Maybe WidgetClassFocusFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassFocusFieldCallback)
-> IO (FunPtr C_WidgetClassFocusFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassFocusFieldCallback
val' -> do
        let val'' :: WidgetClassFocusFieldCallback
val'' = FunPtr C_WidgetClassFocusFieldCallback
-> WidgetClassFocusFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassFocusFieldCallback
-> a -> DirectionType -> m Bool
Gtk.Callbacks.dynamic_WidgetClassKeynavFailedFieldCallback FunPtr C_WidgetClassFocusFieldCallback
val'
        WidgetClassFocusFieldCallback -> IO WidgetClassFocusFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassFocusFieldCallback
val''
    return result

-- | Set the value of the “@keynav_failed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #keynavFailed 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback -> m ()
setWidgetClassKeynavFailed :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassKeynavFailed WidgetClass
s FunPtr C_WidgetClassFocusFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassFocusFieldCallback)
-> FunPtr C_WidgetClassFocusFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) (FunPtr C_WidgetClassFocusFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)

-- | Set the value of the “@keynav_failed@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #keynavFailed
-- @
clearWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m ()
clearWidgetClassKeynavFailed :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassKeynavFailed WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassFocusFieldCallback)
-> FunPtr C_WidgetClassFocusFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) (FunPtr C_WidgetClassFocusFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassKeynavFailedFieldInfo
instance AttrInfo WidgetClassKeynavFailedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassKeynavFailedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassKeynavFailedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassKeynavFailedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassKeynavFailedFieldInfo = (~)Gtk.Callbacks.WidgetClassKeynavFailedFieldCallback
    type AttrTransferType WidgetClassKeynavFailedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)
    type AttrGetType WidgetClassKeynavFailedFieldInfo = Maybe Gtk.Callbacks.WidgetClassKeynavFailedFieldCallback
    type AttrLabel WidgetClassKeynavFailedFieldInfo = "keynav_failed"
    type AttrOrigin WidgetClassKeynavFailedFieldInfo = WidgetClass
    attrGet = getWidgetClassKeynavFailed
    attrSet = setWidgetClassKeynavFailed
    attrConstruct = undefined
    attrClear = clearWidgetClassKeynavFailed
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassKeynavFailedFieldCallback (Gtk.Callbacks.wrap_WidgetClassKeynavFailedFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.keynavFailed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:keynavFailed"
        })

widgetClass_keynavFailed :: AttrLabelProxy "keynavFailed"
widgetClass_keynavFailed = AttrLabelProxy

#endif


-- | Get the value of the “@query_tooltip@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #queryTooltip
-- @
getWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassQueryTooltipFieldCallback)
getWidgetClassQueryTooltip :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassQueryTooltipFieldCallback)
getWidgetClassQueryTooltip WidgetClass
s = IO (Maybe WidgetClassQueryTooltipFieldCallback)
-> m (Maybe WidgetClassQueryTooltipFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassQueryTooltipFieldCallback)
 -> m (Maybe WidgetClassQueryTooltipFieldCallback))
-> IO (Maybe WidgetClassQueryTooltipFieldCallback)
-> m (Maybe WidgetClassQueryTooltipFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
-> IO (Maybe WidgetClassQueryTooltipFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
 -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
-> IO (Maybe WidgetClassQueryTooltipFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
-> IO (FunPtr C_WidgetClassQueryTooltipFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
288) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassQueryTooltipFieldCallback
val' -> do
        let val'' :: WidgetClassQueryTooltipFieldCallback
val'' = FunPtr C_WidgetClassQueryTooltipFieldCallback
-> WidgetClassQueryTooltipFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsTooltip b) =>
FunPtr C_WidgetClassQueryTooltipFieldCallback
-> a -> Int32 -> Int32 -> Bool -> b -> m Bool
Gtk.Callbacks.dynamic_WidgetClassQueryTooltipFieldCallback FunPtr C_WidgetClassQueryTooltipFieldCallback
val'
        WidgetClassQueryTooltipFieldCallback
-> IO WidgetClassQueryTooltipFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassQueryTooltipFieldCallback
val''
    return result

-- | Set the value of the “@query_tooltip@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #queryTooltip 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback -> m ()
setWidgetClassQueryTooltip :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassQueryTooltipFieldCallback -> m ()
setWidgetClassQueryTooltip WidgetClass
s FunPtr C_WidgetClassQueryTooltipFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
-> FunPtr C_WidgetClassQueryTooltipFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
288) (FunPtr C_WidgetClassQueryTooltipFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)

-- | Set the value of the “@query_tooltip@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #queryTooltip
-- @
clearWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m ()
clearWidgetClassQueryTooltip :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassQueryTooltip WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
-> FunPtr C_WidgetClassQueryTooltipFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
288) (FunPtr C_WidgetClassQueryTooltipFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassQueryTooltipFieldInfo
instance AttrInfo WidgetClassQueryTooltipFieldInfo where
    type AttrBaseTypeConstraint WidgetClassQueryTooltipFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassQueryTooltipFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassQueryTooltipFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)
    type AttrTransferTypeConstraint WidgetClassQueryTooltipFieldInfo = (~)Gtk.Callbacks.WidgetClassQueryTooltipFieldCallback
    type AttrTransferType WidgetClassQueryTooltipFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)
    type AttrGetType WidgetClassQueryTooltipFieldInfo = Maybe Gtk.Callbacks.WidgetClassQueryTooltipFieldCallback
    type AttrLabel WidgetClassQueryTooltipFieldInfo = "query_tooltip"
    type AttrOrigin WidgetClassQueryTooltipFieldInfo = WidgetClass
    attrGet = getWidgetClassQueryTooltip
    attrSet = setWidgetClassQueryTooltip
    attrConstruct = undefined
    attrClear = clearWidgetClassQueryTooltip
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassQueryTooltipFieldCallback (Gtk.Callbacks.wrap_WidgetClassQueryTooltipFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.queryTooltip"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:queryTooltip"
        })

widgetClass_queryTooltip :: AttrLabelProxy "queryTooltip"
widgetClass_queryTooltip = AttrLabelProxy

#endif


-- | Get the value of the “@compute_expand@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #computeExpand
-- @
getWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassComputeExpandFieldCallback)
getWidgetClassComputeExpand :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassComputeExpandFieldCallback)
getWidgetClassComputeExpand WidgetClass
s = IO (Maybe WidgetClassComputeExpandFieldCallback)
-> m (Maybe WidgetClassComputeExpandFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassComputeExpandFieldCallback)
 -> m (Maybe WidgetClassComputeExpandFieldCallback))
-> IO (Maybe WidgetClassComputeExpandFieldCallback)
-> m (Maybe WidgetClassComputeExpandFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassComputeExpandFieldCallback))
-> IO (Maybe WidgetClassComputeExpandFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassComputeExpandFieldCallback))
 -> IO (Maybe WidgetClassComputeExpandFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassComputeExpandFieldCallback))
-> IO (Maybe WidgetClassComputeExpandFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
-> IO (FunPtr C_WidgetClassComputeExpandFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
296) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassComputeExpandFieldCallback
val' -> do
        let val'' :: WidgetClassComputeExpandFieldCallback
val'' = FunPtr C_WidgetClassComputeExpandFieldCallback
-> WidgetClassComputeExpandFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassComputeExpandFieldCallback
-> a -> Bool -> Bool -> m ()
Gtk.Callbacks.dynamic_WidgetClassComputeExpandFieldCallback FunPtr C_WidgetClassComputeExpandFieldCallback
val'
        WidgetClassComputeExpandFieldCallback
-> IO WidgetClassComputeExpandFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassComputeExpandFieldCallback
val''
    return result

-- | Set the value of the “@compute_expand@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #computeExpand 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassComputeExpand :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback -> m ()
setWidgetClassComputeExpand :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassComputeExpandFieldCallback -> m ()
setWidgetClassComputeExpand WidgetClass
s FunPtr C_WidgetClassComputeExpandFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
-> FunPtr C_WidgetClassComputeExpandFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
296) (FunPtr C_WidgetClassComputeExpandFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)

-- | Set the value of the “@compute_expand@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #computeExpand
-- @
clearWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m ()
clearWidgetClassComputeExpand :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassComputeExpand WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
-> FunPtr C_WidgetClassComputeExpandFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
296) (FunPtr C_WidgetClassComputeExpandFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassComputeExpandFieldInfo
instance AttrInfo WidgetClassComputeExpandFieldInfo where
    type AttrBaseTypeConstraint WidgetClassComputeExpandFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassComputeExpandFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassComputeExpandFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)
    type AttrTransferTypeConstraint WidgetClassComputeExpandFieldInfo = (~)Gtk.Callbacks.WidgetClassComputeExpandFieldCallback
    type AttrTransferType WidgetClassComputeExpandFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)
    type AttrGetType WidgetClassComputeExpandFieldInfo = Maybe Gtk.Callbacks.WidgetClassComputeExpandFieldCallback
    type AttrLabel WidgetClassComputeExpandFieldInfo = "compute_expand"
    type AttrOrigin WidgetClassComputeExpandFieldInfo = WidgetClass
    attrGet = getWidgetClassComputeExpand
    attrSet = setWidgetClassComputeExpand
    attrConstruct = undefined
    attrClear = clearWidgetClassComputeExpand
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassComputeExpandFieldCallback (Gtk.Callbacks.wrap_WidgetClassComputeExpandFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.computeExpand"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:computeExpand"
        })

widgetClass_computeExpand :: AttrLabelProxy "computeExpand"
widgetClass_computeExpand = AttrLabelProxy

#endif


-- | Get the value of the “@css_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #cssChanged
-- @
getWidgetClassCssChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassCssChangedFieldCallback)
getWidgetClassCssChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassCssChangedFieldCallback)
getWidgetClassCssChanged WidgetClass
s = IO (Maybe WidgetClassCssChangedFieldCallback)
-> m (Maybe WidgetClassCssChangedFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassCssChangedFieldCallback)
 -> m (Maybe WidgetClassCssChangedFieldCallback))
-> IO (Maybe WidgetClassCssChangedFieldCallback)
-> m (Maybe WidgetClassCssChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassCssChangedFieldCallback))
-> IO (Maybe WidgetClassCssChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassCssChangedFieldCallback))
 -> IO (Maybe WidgetClassCssChangedFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassCssChangedFieldCallback))
-> IO (Maybe WidgetClassCssChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
-> IO (FunPtr C_WidgetClassCssChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
304) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassCssChangedFieldCallback
val' -> do
        let val'' :: WidgetClassCssChangedFieldCallback
val'' = FunPtr C_WidgetClassCssChangedFieldCallback
-> WidgetClassCssChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassCssChangedFieldCallback
-> a -> CssStyleChange -> m ()
Gtk.Callbacks.dynamic_WidgetClassCssChangedFieldCallback FunPtr C_WidgetClassCssChangedFieldCallback
val'
        WidgetClassCssChangedFieldCallback
-> IO WidgetClassCssChangedFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassCssChangedFieldCallback
val''
    return result

-- | Set the value of the “@css_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #cssChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassCssChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback -> m ()
setWidgetClassCssChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassCssChangedFieldCallback -> m ()
setWidgetClassCssChanged WidgetClass
s FunPtr C_WidgetClassCssChangedFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
-> FunPtr C_WidgetClassCssChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
304) (FunPtr C_WidgetClassCssChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)

-- | Set the value of the “@css_changed@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #cssChanged
-- @
clearWidgetClassCssChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassCssChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassCssChanged WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
-> FunPtr C_WidgetClassCssChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
304) (FunPtr C_WidgetClassCssChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassCssChangedFieldInfo
instance AttrInfo WidgetClassCssChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassCssChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassCssChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassCssChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassCssChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassCssChangedFieldCallback
    type AttrTransferType WidgetClassCssChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)
    type AttrGetType WidgetClassCssChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassCssChangedFieldCallback
    type AttrLabel WidgetClassCssChangedFieldInfo = "css_changed"
    type AttrOrigin WidgetClassCssChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassCssChanged
    attrSet = setWidgetClassCssChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassCssChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassCssChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassCssChangedFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.cssChanged"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:cssChanged"
        })

widgetClass_cssChanged :: AttrLabelProxy "cssChanged"
widgetClass_cssChanged = AttrLabelProxy

#endif


-- | Get the value of the “@system_setting_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #systemSettingChanged
-- @
getWidgetClassSystemSettingChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSystemSettingChangedFieldCallback)
getWidgetClassSystemSettingChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassSystemSettingChangedFieldCallback)
getWidgetClassSystemSettingChanged WidgetClass
s = IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
-> m (Maybe WidgetClassSystemSettingChangedFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
 -> m (Maybe WidgetClassSystemSettingChangedFieldCallback))
-> IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
-> m (Maybe WidgetClassSystemSettingChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
-> IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
 -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
-> IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
312) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val' -> do
        let val'' :: WidgetClassSystemSettingChangedFieldCallback
val'' = FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> WidgetClassSystemSettingChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> a -> SystemSetting -> m ()
Gtk.Callbacks.dynamic_WidgetClassSystemSettingChangedFieldCallback FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val'
        WidgetClassSystemSettingChangedFieldCallback
-> IO WidgetClassSystemSettingChangedFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSystemSettingChangedFieldCallback
val''
    return result

-- | Set the value of the “@system_setting_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #systemSettingChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSystemSettingChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback -> m ()
setWidgetClassSystemSettingChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassSystemSettingChanged WidgetClass
s FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
312) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)

-- | Set the value of the “@system_setting_changed@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #systemSettingChanged
-- @
clearWidgetClassSystemSettingChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSystemSettingChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSystemSettingChanged WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
312) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSystemSettingChangedFieldInfo
instance AttrInfo WidgetClassSystemSettingChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSystemSettingChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSystemSettingChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSystemSettingChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSystemSettingChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassSystemSettingChangedFieldCallback
    type AttrTransferType WidgetClassSystemSettingChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)
    type AttrGetType WidgetClassSystemSettingChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassSystemSettingChangedFieldCallback
    type AttrLabel WidgetClassSystemSettingChangedFieldInfo = "system_setting_changed"
    type AttrOrigin WidgetClassSystemSettingChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassSystemSettingChanged
    attrSet = setWidgetClassSystemSettingChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassSystemSettingChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSystemSettingChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassSystemSettingChangedFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.systemSettingChanged"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:systemSettingChanged"
        })

widgetClass_systemSettingChanged :: AttrLabelProxy "systemSettingChanged"
widgetClass_systemSettingChanged = AttrLabelProxy

#endif


-- | Get the value of the “@snapshot@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #snapshot
-- @
getWidgetClassSnapshot :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSnapshotFieldCallback)
getWidgetClassSnapshot :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassSnapshotFieldCallback)
getWidgetClassSnapshot WidgetClass
s = IO (Maybe WidgetClassSnapshotFieldCallback)
-> m (Maybe WidgetClassSnapshotFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassSnapshotFieldCallback)
 -> m (Maybe WidgetClassSnapshotFieldCallback))
-> IO (Maybe WidgetClassSnapshotFieldCallback)
-> m (Maybe WidgetClassSnapshotFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassSnapshotFieldCallback))
-> IO (Maybe WidgetClassSnapshotFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassSnapshotFieldCallback))
 -> IO (Maybe WidgetClassSnapshotFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassSnapshotFieldCallback))
-> IO (Maybe WidgetClassSnapshotFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
-> IO (FunPtr C_WidgetClassSnapshotFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
320) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassSnapshotFieldCallback
val' -> do
        let val'' :: WidgetClassSnapshotFieldCallback
val'' = FunPtr C_WidgetClassSnapshotFieldCallback
-> WidgetClassSnapshotFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsSnapshot b) =>
FunPtr C_WidgetClassSnapshotFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_WidgetClassSnapshotFieldCallback FunPtr C_WidgetClassSnapshotFieldCallback
val'
        WidgetClassSnapshotFieldCallback
-> IO WidgetClassSnapshotFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSnapshotFieldCallback
val''
    return result

-- | Set the value of the “@snapshot@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #snapshot 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSnapshot :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback -> m ()
setWidgetClassSnapshot :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassSnapshotFieldCallback -> m ()
setWidgetClassSnapshot WidgetClass
s FunPtr C_WidgetClassSnapshotFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
-> FunPtr C_WidgetClassSnapshotFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
320) (FunPtr C_WidgetClassSnapshotFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)

-- | Set the value of the “@snapshot@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #snapshot
-- @
clearWidgetClassSnapshot :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSnapshot :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSnapshot WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
-> FunPtr C_WidgetClassSnapshotFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
320) (FunPtr C_WidgetClassSnapshotFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSnapshotFieldInfo
instance AttrInfo WidgetClassSnapshotFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSnapshotFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSnapshotFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSnapshotFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSnapshotFieldInfo = (~)Gtk.Callbacks.WidgetClassSnapshotFieldCallback
    type AttrTransferType WidgetClassSnapshotFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)
    type AttrGetType WidgetClassSnapshotFieldInfo = Maybe Gtk.Callbacks.WidgetClassSnapshotFieldCallback
    type AttrLabel WidgetClassSnapshotFieldInfo = "snapshot"
    type AttrOrigin WidgetClassSnapshotFieldInfo = WidgetClass
    attrGet = getWidgetClassSnapshot
    attrSet = setWidgetClassSnapshot
    attrConstruct = undefined
    attrClear = clearWidgetClassSnapshot
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSnapshotFieldCallback (Gtk.Callbacks.wrap_WidgetClassSnapshotFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.snapshot"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:snapshot"
        })

widgetClass_snapshot :: AttrLabelProxy "snapshot"
widgetClass_snapshot = AttrLabelProxy

#endif


-- | Get the value of the “@contains@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #contains
-- @
getWidgetClassContains :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassContainsFieldCallback)
getWidgetClassContains :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassContainsFieldCallback)
getWidgetClassContains WidgetClass
s = IO (Maybe WidgetClassContainsFieldCallback)
-> m (Maybe WidgetClassContainsFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassContainsFieldCallback)
 -> m (Maybe WidgetClassContainsFieldCallback))
-> IO (Maybe WidgetClassContainsFieldCallback)
-> m (Maybe WidgetClassContainsFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassContainsFieldCallback))
-> IO (Maybe WidgetClassContainsFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassContainsFieldCallback))
 -> IO (Maybe WidgetClassContainsFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassContainsFieldCallback))
-> IO (Maybe WidgetClassContainsFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    val <- Ptr (FunPtr C_WidgetClassContainsFieldCallback)
-> IO (FunPtr C_WidgetClassContainsFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassContainsFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
328) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_WidgetClassContainsFieldCallback
val' -> do
        let val'' :: WidgetClassContainsFieldCallback
val'' = FunPtr C_WidgetClassContainsFieldCallback
-> WidgetClassContainsFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassContainsFieldCallback
-> a -> Double -> Double -> m Bool
Gtk.Callbacks.dynamic_WidgetClassContainsFieldCallback FunPtr C_WidgetClassContainsFieldCallback
val'
        WidgetClassContainsFieldCallback
-> IO WidgetClassContainsFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassContainsFieldCallback
val''
    return result

-- | Set the value of the “@contains@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #contains 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassContains :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback -> m ()
setWidgetClassContains :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassContainsFieldCallback -> m ()
setWidgetClassContains WidgetClass
s FunPtr C_WidgetClassContainsFieldCallback
val = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassContainsFieldCallback)
-> FunPtr C_WidgetClassContainsFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassContainsFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
328) (FunPtr C_WidgetClassContainsFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)

-- | Set the value of the “@contains@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #contains
-- @
clearWidgetClassContains :: MonadIO m => WidgetClass -> m ()
clearWidgetClassContains :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassContains WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassContainsFieldCallback)
-> FunPtr C_WidgetClassContainsFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassContainsFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
328) (FunPtr C_WidgetClassContainsFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassContainsFieldInfo
instance AttrInfo WidgetClassContainsFieldInfo where
    type AttrBaseTypeConstraint WidgetClassContainsFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassContainsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassContainsFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)
    type AttrTransferTypeConstraint WidgetClassContainsFieldInfo = (~)Gtk.Callbacks.WidgetClassContainsFieldCallback
    type AttrTransferType WidgetClassContainsFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)
    type AttrGetType WidgetClassContainsFieldInfo = Maybe Gtk.Callbacks.WidgetClassContainsFieldCallback
    type AttrLabel WidgetClassContainsFieldInfo = "contains"
    type AttrOrigin WidgetClassContainsFieldInfo = WidgetClass
    attrGet = getWidgetClassContains
    attrSet = setWidgetClassContains
    attrConstruct = undefined
    attrClear = clearWidgetClassContains
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassContainsFieldCallback (Gtk.Callbacks.wrap_WidgetClassContainsFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.contains"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:contains"
        })

widgetClass_contains :: AttrLabelProxy "contains"
widgetClass_contains = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList WidgetClass
type instance O.AttributeList WidgetClass = WidgetClassAttributeList
type WidgetClassAttributeList = ('[ '("parentClass", WidgetClassParentClassFieldInfo), '("show", WidgetClassShowFieldInfo), '("hide", WidgetClassHideFieldInfo), '("map", WidgetClassMapFieldInfo), '("unmap", WidgetClassUnmapFieldInfo), '("realize", WidgetClassRealizeFieldInfo), '("unrealize", WidgetClassUnrealizeFieldInfo), '("root", WidgetClassRootFieldInfo), '("unroot", WidgetClassUnrootFieldInfo), '("sizeAllocate", WidgetClassSizeAllocateFieldInfo), '("stateFlagsChanged", WidgetClassStateFlagsChangedFieldInfo), '("directionChanged", WidgetClassDirectionChangedFieldInfo), '("getRequestMode", WidgetClassGetRequestModeFieldInfo), '("measure", WidgetClassMeasureFieldInfo), '("mnemonicActivate", WidgetClassMnemonicActivateFieldInfo), '("grabFocus", WidgetClassGrabFocusFieldInfo), '("focus", WidgetClassFocusFieldInfo), '("setFocusChild", WidgetClassSetFocusChildFieldInfo), '("moveFocus", WidgetClassMoveFocusFieldInfo), '("keynavFailed", WidgetClassKeynavFailedFieldInfo), '("queryTooltip", WidgetClassQueryTooltipFieldInfo), '("computeExpand", WidgetClassComputeExpandFieldInfo), '("cssChanged", WidgetClassCssChangedFieldInfo), '("systemSettingChanged", WidgetClassSystemSettingChangedFieldInfo), '("snapshot", WidgetClassSnapshotFieldInfo), '("contains", WidgetClassContainsFieldInfo)] :: [(Symbol, DK.Type)])
#endif

-- method WidgetClass::add_shortcut
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the class to add the shortcut to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "shortcut"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Shortcut" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the shortcut to add"
--                 , 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_widget_class_add_shortcut" gtk_widget_class_add_shortcut :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    Ptr Gtk.Shortcut.Shortcut ->            -- shortcut : TInterface (Name {namespace = "Gtk", name = "Shortcut"})
    IO ()

-- | Installs a shortcut in /@widgetClass@/.
-- 
-- Every instance created for /@widgetClass@/ or its subclasses will
-- inherit this shortcut and trigger it.
-- 
-- Shortcuts added this way will be triggered in the 'GI.Gtk.Enums.PropagationPhaseBubble'
-- phase, which means they may also trigger if child widgets have focus.
-- 
-- This function must only be used in class initialization functions
-- otherwise it is not guaranteed that the shortcut will be installed.
widgetClassAddShortcut ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Shortcut.IsShortcut a) =>
    WidgetClass
    -- ^ /@widgetClass@/: the class to add the shortcut to
    -> a
    -- ^ /@shortcut@/: the shortcut to add
    -> m ()
widgetClassAddShortcut :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShortcut a) =>
WidgetClass -> a -> m ()
widgetClassAddShortcut WidgetClass
widgetClass a
shortcut = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    shortcut' <- unsafeManagedPtrCastPtr shortcut
    gtk_widget_class_add_shortcut widgetClass' shortcut'
    touchManagedPtr widgetClass
    touchManagedPtr shortcut
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassAddShortcutMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, Gtk.Shortcut.IsShortcut a) => O.OverloadedMethod WidgetClassAddShortcutMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassAddShortcut

instance O.OverloadedMethodInfo WidgetClassAddShortcutMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassAddShortcut",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassAddShortcut"
        })


#endif

-- method WidgetClass::bind_template_callback_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "name of the callback as expected in the template XML"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback_symbol"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Callback" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the callback symbol"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_bind_template_callback_full" gtk_widget_class_bind_template_callback_full :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- callback_name : TBasicType TUTF8
    FunPtr GObject.Callbacks.C_Callback ->  -- callback_symbol : TInterface (Name {namespace = "GObject", name = "Callback"})
    IO ()

-- | Associates a name to be used in GtkBuilder XML with a symbol.
-- 
-- This function is not supported after 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateScope'
-- has been used on /@widgetClass@/.
-- 
-- See 'GI.Gtk.Objects.BuilderCScope.builderCScopeAddCallbackSymbol'.
-- 
-- Note that this must be called from a composite widget classes
-- class initializer after calling 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
widgetClassBindTemplateCallbackFull ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> T.Text
    -- ^ /@callbackName@/: name of the callback as expected in the template XML
    -> GObject.Callbacks.Callback
    -- ^ /@callbackSymbol@/: the callback symbol
    -> m ()
widgetClassBindTemplateCallbackFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> IO () -> m ()
widgetClassBindTemplateCallbackFull WidgetClass
widgetClass Text
callbackName IO ()
callbackSymbol = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    callbackName' <- textToCString callbackName
    ptrcallbackSymbol <- callocMem :: IO (Ptr (FunPtr GObject.Callbacks.C_Callback))
    callbackSymbol' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback (Just ptrcallbackSymbol) callbackSymbol)
    poke ptrcallbackSymbol callbackSymbol'
    gtk_widget_class_bind_template_callback_full widgetClass' callbackName' callbackSymbol'
    touchManagedPtr widgetClass
    freeMem callbackName'
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassBindTemplateCallbackFullMethodInfo
instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassBindTemplateCallbackFullMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassBindTemplateCallbackFull

instance O.OverloadedMethodInfo WidgetClassBindTemplateCallbackFullMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassBindTemplateCallbackFull",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassBindTemplateCallbackFull"
        })


#endif

-- method WidgetClass::bind_template_child_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ID of the child defined in the template XML"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "internal_child"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "whether the child should be accessible as an \8220internal-child\8221\n  when this class is used in GtkBuilder XML"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "struct_offset"
--           , argType = TBasicType TSSize
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The offset into the composite widget\8217s instance\n  public or private structure where the automated child pointer should be set,\n  or 0 to not assign the pointer"
--                 , 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_widget_class_bind_template_child_full" gtk_widget_class_bind_template_child_full :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- name : TBasicType TUTF8
    CInt ->                                 -- internal_child : TBasicType TBoolean
    DI.Int64 ->                             -- struct_offset : TBasicType TSSize
    IO ()

-- | Assigns an object declared in the class template XML to be set to
-- a location on a freshly built instance’s private data, or
-- alternatively accessible via 'GI.Gtk.Objects.Widget.widgetGetTemplateChild'.
-- 
-- The struct can point either into the public instance, then you should
-- use @G_STRUCT_OFFSET(WidgetType, member)@ for /@structOffset@/, or in the
-- private struct, then you should use @G_PRIVATE_OFFSET(WidgetType, member)@.
-- 
-- An explicit strong reference will be held automatically for the duration
-- of your instance’s life cycle, it will be released automatically when
-- @GObjectClass.dispose()@ runs on your instance and if a nonzero /@structOffset@/
-- is specified, then the automatic location in your instance public or private
-- data will be set to @NULL@. You can however access an automated child pointer
-- the first time your classes @GObjectClass.dispose()@ runs, or alternatively
-- in [Widget::destroy]("GI.Gtk.Objects.Widget#g:signal:destroy").
-- 
-- If /@internalChild@/ is specified, t'GI.Gtk.Interfaces.Buildable.Buildable'.@/get_internal_child/@()
-- will be automatically implemented by the widget class so there is no
-- need to implement it manually.
-- 
-- The wrapper macros @/Gtk.widget_class_bind_template_child/@,
-- @/Gtk.widget_class_bind_template_child_internal/@,
-- @/Gtk.widget_class_bind_template_child_private/@ and
-- @/Gtk.widget_class_bind_template_child_internal_private/@
-- might be more convenient to use.
-- 
-- Note that this must be called from a composite widget classes class
-- initializer after calling 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
widgetClassBindTemplateChildFull ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> T.Text
    -- ^ /@name@/: ID of the child defined in the template XML
    -> Bool
    -- ^ /@internalChild@/: whether the child should be accessible as an “internal-child”
    --   when this class is used in GtkBuilder XML
    -> DI.Int64
    -- ^ /@structOffset@/: The offset into the composite widget’s instance
    --   public or private structure where the automated child pointer should be set,
    --   or 0 to not assign the pointer
    -> m ()
widgetClassBindTemplateChildFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> Bool -> Int64 -> m ()
widgetClassBindTemplateChildFull WidgetClass
widgetClass Text
name Bool
internalChild Int64
structOffset = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    name' <- textToCString name
    let internalChild' = (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
internalChild
    gtk_widget_class_bind_template_child_full widgetClass' name' internalChild' structOffset
    touchManagedPtr widgetClass
    freeMem name'
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassBindTemplateChildFullMethodInfo
instance (signature ~ (T.Text -> Bool -> DI.Int64 -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassBindTemplateChildFullMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassBindTemplateChildFull

instance O.OverloadedMethodInfo WidgetClassBindTemplateChildFullMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassBindTemplateChildFull",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassBindTemplateChildFull"
        })


#endif

-- method WidgetClass::get_accessible_role
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "AccessibleRole" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_get_accessible_role" gtk_widget_class_get_accessible_role :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    IO CUInt

-- | Retrieves the accessible role used by the given widget class.
-- 
-- Different accessible roles have different states, and are rendered
-- differently by assistive technologies.
-- 
-- See also: 'GI.Gtk.Interfaces.Accessible.accessibleGetAccessibleRole'.
widgetClassGetAccessibleRole ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> m Gtk.Enums.AccessibleRole
    -- ^ __Returns:__ the accessible role for the widget class
widgetClassGetAccessibleRole :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> m AccessibleRole
widgetClassGetAccessibleRole WidgetClass
widgetClass = IO AccessibleRole -> m AccessibleRole
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AccessibleRole -> m AccessibleRole)
-> IO AccessibleRole -> m AccessibleRole
forall a b. (a -> b) -> a -> b
$ do
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    result <- gtk_widget_class_get_accessible_role widgetClass'
    let result' = (Int -> AccessibleRole
forall a. Enum a => Int -> a
toEnum (Int -> AccessibleRole)
-> (CUInt -> Int) -> CUInt -> AccessibleRole
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    touchManagedPtr widgetClass
    return result'

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetAccessibleRoleMethodInfo
instance (signature ~ (m Gtk.Enums.AccessibleRole), MonadIO m) => O.OverloadedMethod WidgetClassGetAccessibleRoleMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassGetAccessibleRole

instance O.OverloadedMethodInfo WidgetClassGetAccessibleRoleMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassGetAccessibleRole",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetAccessibleRole"
        })


#endif

-- method WidgetClass::get_activate_signal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_get_activate_signal" gtk_widget_class_get_activate_signal :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    IO Word32

-- | Retrieves the signal id for the activation signal.
-- 
-- The activation signal is set using
-- 'GI.Gtk.Structs.WidgetClass.widgetClassSetActivateSignal'.
widgetClassGetActivateSignal ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> m Word32
    -- ^ __Returns:__ a signal id, or 0 if the widget class does not
    --   specify an activation signal
widgetClassGetActivateSignal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> m Word32
widgetClassGetActivateSignal WidgetClass
widgetClass = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    result <- gtk_widget_class_get_activate_signal widgetClass'
    touchManagedPtr widgetClass
    return result

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetActivateSignalMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod WidgetClassGetActivateSignalMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassGetActivateSignal

instance O.OverloadedMethodInfo WidgetClassGetActivateSignalMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassGetActivateSignal",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetActivateSignal"
        })


#endif

-- method WidgetClass::get_css_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "class to set the name on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_get_css_name" gtk_widget_class_get_css_name :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    IO CString

-- | Gets the name used by this class for matching in CSS code.
-- 
-- See 'GI.Gtk.Structs.WidgetClass.widgetClassSetCssName' for details.
widgetClassGetCssName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: class to set the name on
    -> m T.Text
    -- ^ __Returns:__ the CSS name of the given class
widgetClassGetCssName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> m Text
widgetClassGetCssName WidgetClass
widgetClass = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    result <- gtk_widget_class_get_css_name widgetClass'
    checkUnexpectedReturnNULL "widgetClassGetCssName" result
    result' <- cstringToText result
    touchManagedPtr widgetClass
    return result'

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetCssNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod WidgetClassGetCssNameMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassGetCssName

instance O.OverloadedMethodInfo WidgetClassGetCssNameMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassGetCssName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetCssName"
        })


#endif

-- method WidgetClass::get_layout_manager_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TGType)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_get_layout_manager_type" gtk_widget_class_get_layout_manager_type :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    IO CGType

-- | Retrieves the type of the t'GI.Gtk.Objects.LayoutManager.LayoutManager'
-- used by widgets of class /@widgetClass@/.
-- 
-- See also: 'GI.Gtk.Structs.WidgetClass.widgetClassSetLayoutManagerType'.
widgetClassGetLayoutManagerType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> m GType
    -- ^ __Returns:__ type of a @GtkLayoutManager@ subclass, or @G_TYPE_INVALID@
widgetClassGetLayoutManagerType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> m GType
widgetClassGetLayoutManagerType WidgetClass
widgetClass = IO GType -> m GType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ do
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    result <- gtk_widget_class_get_layout_manager_type widgetClass'
    let result' = CGType -> GType
GType CGType
result
    touchManagedPtr widgetClass
    return result'

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetLayoutManagerTypeMethodInfo
instance (signature ~ (m GType), MonadIO m) => O.OverloadedMethod WidgetClassGetLayoutManagerTypeMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassGetLayoutManagerType

instance O.OverloadedMethodInfo WidgetClassGetLayoutManagerTypeMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassGetLayoutManagerType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetLayoutManagerType"
        })


#endif

-- method WidgetClass::install_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "action_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a prefixed action name, such as \"clipboard.paste\""
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parameter_type"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the parameter type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "activate"
--           , argType =
--               TInterface
--                 Name { namespace = "Gtk" , name = "WidgetActionActivateFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "callback to use when the action is activated"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_install_action" gtk_widget_class_install_action :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- action_name : TBasicType TUTF8
    CString ->                              -- parameter_type : TBasicType TUTF8
    FunPtr Gtk.Callbacks.C_WidgetActionActivateFunc -> -- activate : TInterface (Name {namespace = "Gtk", name = "WidgetActionActivateFunc"})
    IO ()

-- | Adds an action for all instances of a widget class.
-- 
-- This function should be called at class initialization time.
-- 
-- Actions installed by this function are stateless. The only state
-- they have is whether they are enabled or not (which can be changed
-- with 'GI.Gtk.Objects.Widget.widgetActionSetEnabled').
widgetClassInstallAction ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> T.Text
    -- ^ /@actionName@/: a prefixed action name, such as \"clipboard.paste\"
    -> Maybe (T.Text)
    -- ^ /@parameterType@/: the parameter type
    -> Gtk.Callbacks.WidgetActionActivateFunc
    -- ^ /@activate@/: callback to use when the action is activated
    -> m ()
widgetClassInstallAction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass
-> Text -> Maybe Text -> WidgetActionActivateFunc -> m ()
widgetClassInstallAction WidgetClass
widgetClass Text
actionName Maybe Text
parameterType WidgetActionActivateFunc
activate = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    actionName' <- textToCString actionName
    maybeParameterType <- case parameterType of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jParameterType -> do
            jParameterType' <- Text -> IO CString
textToCString Text
jParameterType
            return jParameterType'
    activate' <- Gtk.Callbacks.mk_WidgetActionActivateFunc (Gtk.Callbacks.wrap_WidgetActionActivateFunc Nothing activate)
    gtk_widget_class_install_action widgetClass' actionName' maybeParameterType activate'
    touchManagedPtr widgetClass
    freeMem actionName'
    freeMem maybeParameterType
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassInstallActionMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> Gtk.Callbacks.WidgetActionActivateFunc -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassInstallActionMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassInstallAction

instance O.OverloadedMethodInfo WidgetClassInstallActionMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassInstallAction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassInstallAction"
        })


#endif

-- method WidgetClass::install_property_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "action_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of the action" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "name of a property in instances of @widget_class\n  or any parent class"
--                 , 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_widget_class_install_property_action" gtk_widget_class_install_property_action :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- action_name : TBasicType TUTF8
    CString ->                              -- property_name : TBasicType TUTF8
    IO ()

-- | Installs an action called /@actionName@/ on /@widgetClass@/ and
-- binds its state to the value of the /@propertyName@/ property.
-- 
-- This function will perform a few sanity checks on the property selected
-- via /@propertyName@/. Namely, the property must exist, must be readable,
-- writable and must not be construct-only. There are also restrictions
-- on the type of the given property, it must be boolean, int, unsigned int,
-- double or string. If any of these conditions are not met, a critical
-- warning will be printed and no action will be added.
-- 
-- The state type of the action matches the property type.
-- 
-- If the property is boolean, the action will have no parameter and
-- toggle the property value. Otherwise, the action will have a parameter
-- of the same type as the property.
widgetClassInstallPropertyAction ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> T.Text
    -- ^ /@actionName@/: name of the action
    -> T.Text
    -- ^ /@propertyName@/: name of a property in instances of /@widgetClass@/
    --   or any parent class
    -> m ()
widgetClassInstallPropertyAction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> Text -> m ()
widgetClassInstallPropertyAction WidgetClass
widgetClass Text
actionName Text
propertyName = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    actionName' <- textToCString actionName
    propertyName' <- textToCString propertyName
    gtk_widget_class_install_property_action widgetClass' actionName' propertyName'
    touchManagedPtr widgetClass
    freeMem actionName'
    freeMem propertyName'
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassInstallPropertyActionMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassInstallPropertyActionMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassInstallPropertyAction

instance O.OverloadedMethodInfo WidgetClassInstallPropertyActionMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassInstallPropertyAction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassInstallPropertyAction"
        })


#endif

-- method WidgetClass::query_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index_"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "position of the action to query"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "owner"
--           , argType = TBasicType TGType
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the type where the action was defined"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "action_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the action name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parameter_type"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "VariantType" }
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the parameter type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the property name"
--                 , 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_widget_class_query_action" gtk_widget_class_query_action :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    Word32 ->                               -- index_ : TBasicType TUInt
    Ptr CGType ->                           -- owner : TBasicType TGType
    Ptr CString ->                          -- action_name : TBasicType TUTF8
    Ptr (Ptr GLib.VariantType.VariantType) -> -- parameter_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
    Ptr CString ->                          -- property_name : TBasicType TUTF8
    IO CInt

-- | Returns details about an action that has been
-- installed for /@widgetClass@/.
-- 
-- See 'GI.Gtk.Structs.WidgetClass.widgetClassInstallAction' for details on
-- how to install actions.
-- 
-- Note that this function will also return actions defined
-- by parent classes. You can identify those by looking
-- at /@owner@/.
widgetClassQueryAction ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> Word32
    -- ^ /@index_@/: position of the action to query
    -> m ((Bool, GType, T.Text, Maybe GLib.VariantType.VariantType, Maybe T.Text))
    -- ^ __Returns:__ true if the action was found
widgetClassQueryAction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass
-> Word32 -> m (Bool, GType, Text, Maybe VariantType, Maybe Text)
widgetClassQueryAction WidgetClass
widgetClass Word32
index_ = IO (Bool, GType, Text, Maybe VariantType, Maybe Text)
-> m (Bool, GType, Text, Maybe VariantType, Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, GType, Text, Maybe VariantType, Maybe Text)
 -> m (Bool, GType, Text, Maybe VariantType, Maybe Text))
-> IO (Bool, GType, Text, Maybe VariantType, Maybe Text)
-> m (Bool, GType, Text, Maybe VariantType, Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    owner <- allocMem :: IO (Ptr CGType)
    actionName <- callocMem :: IO (Ptr CString)
    parameterType <- callocMem :: IO (Ptr (Ptr GLib.VariantType.VariantType))
    propertyName <- callocMem :: IO (Ptr CString)
    result <- gtk_widget_class_query_action widgetClass' index_ owner actionName parameterType propertyName
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    owner' <- peek owner
    let owner'' = CGType -> GType
GType CGType
owner'
    actionName' <- peek actionName
    actionName'' <- cstringToText actionName'
    parameterType' <- peek parameterType
    maybeParameterType' <- convertIfNonNull parameterType' $ \Ptr VariantType
parameterType'' -> do
        parameterType''' <- ((ManagedPtr VariantType -> VariantType)
-> Ptr VariantType -> IO VariantType
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr VariantType -> VariantType
GLib.VariantType.VariantType) Ptr VariantType
parameterType''
        return parameterType'''
    propertyName' <- peek propertyName
    maybePropertyName' <- convertIfNonNull propertyName' $ \CString
propertyName'' -> do
        propertyName''' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
propertyName''
        return propertyName'''
    touchManagedPtr widgetClass
    freeMem owner
    freeMem actionName
    freeMem parameterType
    freeMem propertyName
    return (result', owner'', actionName'', maybeParameterType', maybePropertyName')

#if defined(ENABLE_OVERLOADING)
data WidgetClassQueryActionMethodInfo
instance (signature ~ (Word32 -> m ((Bool, GType, T.Text, Maybe GLib.VariantType.VariantType, Maybe T.Text))), MonadIO m) => O.OverloadedMethod WidgetClassQueryActionMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassQueryAction

instance O.OverloadedMethodInfo WidgetClassQueryActionMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassQueryAction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassQueryAction"
        })


#endif

-- method WidgetClass::set_accessible_role
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "accessible_role"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "AccessibleRole" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the accessible role to use"
--                 , 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_widget_class_set_accessible_role" gtk_widget_class_set_accessible_role :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CUInt ->                                -- accessible_role : TInterface (Name {namespace = "Gtk", name = "AccessibleRole"})
    IO ()

-- | Sets the accessible role used by the given widget class.
-- 
-- Different accessible roles have different states, and are
-- rendered differently by assistive technologies.
widgetClassSetAccessibleRole ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> Gtk.Enums.AccessibleRole
    -- ^ /@accessibleRole@/: the accessible role to use
    -> m ()
widgetClassSetAccessibleRole :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> AccessibleRole -> m ()
widgetClassSetAccessibleRole WidgetClass
widgetClass AccessibleRole
accessibleRole = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    let accessibleRole' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (AccessibleRole -> Int) -> AccessibleRole -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AccessibleRole -> Int
forall a. Enum a => a -> Int
fromEnum) AccessibleRole
accessibleRole
    gtk_widget_class_set_accessible_role widgetClass' accessibleRole'
    touchManagedPtr widgetClass
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetAccessibleRoleMethodInfo
instance (signature ~ (Gtk.Enums.AccessibleRole -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetAccessibleRoleMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetAccessibleRole

instance O.OverloadedMethodInfo WidgetClassSetAccessibleRoleMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetAccessibleRole",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetAccessibleRole"
        })


#endif

-- method WidgetClass::set_activate_signal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "signal_id"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the id for the activate signal"
--                 , 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_widget_class_set_activate_signal" gtk_widget_class_set_activate_signal :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    Word32 ->                               -- signal_id : TBasicType TUInt
    IO ()

-- | Sets the activation signal for a widget class.
-- 
-- The signal will be emitted when calling 'GI.Gtk.Objects.Widget.widgetActivate'.
-- 
-- The /@signalId@/ must have been registered with [function.GObject.signal_new]
-- or @/GObject.signal_newv/@ before calling this function.
widgetClassSetActivateSignal ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> Word32
    -- ^ /@signalId@/: the id for the activate signal
    -> m ()
widgetClassSetActivateSignal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Word32 -> m ()
widgetClassSetActivateSignal WidgetClass
widgetClass Word32
signalId = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    gtk_widget_class_set_activate_signal widgetClass' signalId
    touchManagedPtr widgetClass
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetActivateSignalMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetActivateSignalMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetActivateSignal

instance O.OverloadedMethodInfo WidgetClassSetActivateSignalMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetActivateSignal",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetActivateSignal"
        })


#endif

-- method WidgetClass::set_activate_signal_from_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "signal_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the name of the activate signal of @widget_type"
--                 , 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_widget_class_set_activate_signal_from_name" gtk_widget_class_set_activate_signal_from_name :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- signal_name : TBasicType TUTF8
    IO ()

-- | Sets the activation signal for a widget class.
-- 
-- The signal id will by looked up by /@signalName@/.
-- 
-- The signal will be emitted when calling 'GI.Gtk.Objects.Widget.widgetActivate'.
-- 
-- The /@signalName@/ must have been registered with [function.GObject.signal_new]
-- or @/GObject.signal_newv/@ before calling this function.
widgetClassSetActivateSignalFromName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> T.Text
    -- ^ /@signalName@/: the name of the activate signal of /@widgetType@/
    -> m ()
widgetClassSetActivateSignalFromName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> m ()
widgetClassSetActivateSignalFromName WidgetClass
widgetClass Text
signalName = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    signalName' <- textToCString signalName
    gtk_widget_class_set_activate_signal_from_name widgetClass' signalName'
    touchManagedPtr widgetClass
    freeMem signalName'
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetActivateSignalFromNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetActivateSignalFromNameMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetActivateSignalFromName

instance O.OverloadedMethodInfo WidgetClassSetActivateSignalFromNameMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetActivateSignalFromName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetActivateSignalFromName"
        })


#endif

-- method WidgetClass::set_css_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "class to set the name on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name to use" , 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_widget_class_set_css_name" gtk_widget_class_set_css_name :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Sets the name to be used for CSS matching of widgets.
-- 
-- If this function is not called for a given class, the name
-- set on the parent class is used. By default, @GtkWidget@
-- uses the name \"widget\".
widgetClassSetCssName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: class to set the name on
    -> T.Text
    -- ^ /@name@/: name to use
    -> m ()
widgetClassSetCssName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> m ()
widgetClassSetCssName WidgetClass
widgetClass Text
name = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    name' <- textToCString name
    gtk_widget_class_set_css_name widgetClass' name'
    touchManagedPtr widgetClass
    freeMem name'
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetCssNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetCssNameMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetCssName

instance O.OverloadedMethodInfo WidgetClassSetCssNameMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetCssName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetCssName"
        })


#endif

-- method WidgetClass::set_layout_manager_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the object type that implements the `GtkLayoutManager`\n  for @widget_class"
--                 , 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_widget_class_set_layout_manager_type" gtk_widget_class_set_layout_manager_type :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CGType ->                               -- type : TBasicType TGType
    IO ()

-- | Sets the type to be used for creating layout managers for
-- widgets of /@widgetClass@/.
-- 
-- The given /@type@/ must be a subtype of t'GI.Gtk.Objects.LayoutManager.LayoutManager'.
-- 
-- This function should only be called from class init functions
-- of widgets.
widgetClassSetLayoutManagerType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> GType
    -- ^ /@type@/: the object type that implements the @GtkLayoutManager@
    --   for /@widgetClass@/
    -> m ()
widgetClassSetLayoutManagerType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> GType -> m ()
widgetClassSetLayoutManagerType WidgetClass
widgetClass GType
type_ = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    let type_' = GType -> CGType
gtypeToCGType GType
type_
    gtk_widget_class_set_layout_manager_type widgetClass' type_'
    touchManagedPtr widgetClass
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetLayoutManagerTypeMethodInfo
instance (signature ~ (GType -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetLayoutManagerTypeMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetLayoutManagerType

instance O.OverloadedMethodInfo WidgetClassSetLayoutManagerTypeMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetLayoutManagerType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetLayoutManagerType"
        })


#endif

-- method WidgetClass::set_template
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "template_bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "`GBytes` holding the `GtkBuilder` XML"
--                 , 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_widget_class_set_template" gtk_widget_class_set_template :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    Ptr GLib.Bytes.Bytes ->                 -- template_bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    IO ()

-- | This should be called at class initialization time to specify
-- the @GtkBuilder@ XML to be used to extend a widget.
-- 
-- For convenience, 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateFromResource'
-- is also provided.
-- 
-- Note that any class that installs templates must call
-- 'GI.Gtk.Objects.Widget.widgetInitTemplate' in the widget’s instance initializer.
widgetClassSetTemplate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> GLib.Bytes.Bytes
    -- ^ /@templateBytes@/: @GBytes@ holding the @GtkBuilder@ XML
    -> m ()
widgetClassSetTemplate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Bytes -> m ()
widgetClassSetTemplate WidgetClass
widgetClass Bytes
templateBytes = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    templateBytes' <- unsafeManagedPtrGetPtr templateBytes
    gtk_widget_class_set_template widgetClass' templateBytes'
    touchManagedPtr widgetClass
    touchManagedPtr templateBytes
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetTemplateMethodInfo
instance (signature ~ (GLib.Bytes.Bytes -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetTemplateMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetTemplate

instance O.OverloadedMethodInfo WidgetClassSetTemplateMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetTemplate"
        })


#endif

-- method WidgetClass::set_template_from_resource
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "resource_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "resource path to load the template from"
--                 , 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_widget_class_set_template_from_resource" gtk_widget_class_set_template_from_resource :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- resource_name : TBasicType TUTF8
    IO ()

-- | A convenience function that calls 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'
-- with the contents of a resource.
-- 
-- Note that any class that installs templates must call
-- 'GI.Gtk.Objects.Widget.widgetInitTemplate' in the widget’s instance
-- initializer.
widgetClassSetTemplateFromResource ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> T.Text
    -- ^ /@resourceName@/: resource path to load the template from
    -> m ()
widgetClassSetTemplateFromResource :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> m ()
widgetClassSetTemplateFromResource WidgetClass
widgetClass Text
resourceName = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    resourceName' <- textToCString resourceName
    gtk_widget_class_set_template_from_resource widgetClass' resourceName'
    touchManagedPtr widgetClass
    freeMem resourceName'
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetTemplateFromResourceMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetTemplateFromResourceMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetTemplateFromResource

instance O.OverloadedMethodInfo WidgetClassSetTemplateFromResourceMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateFromResource",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetTemplateFromResource"
        })


#endif

-- method WidgetClass::set_template_scope
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget class" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scope"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "BuilderScope" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "`GtkBuilderScope` to use when loading\n  the class template"
--                 , 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_widget_class_set_template_scope" gtk_widget_class_set_template_scope :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    Ptr Gtk.BuilderScope.BuilderScope ->    -- scope : TInterface (Name {namespace = "Gtk", name = "BuilderScope"})
    IO ()

-- | Overrides the default scope to be used when parsing the class template.
-- 
-- This function is intended for language bindings.
-- 
-- Note that this must be called from a composite widget classes class
-- initializer after calling 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
widgetClassSetTemplateScope ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.BuilderScope.IsBuilderScope a) =>
    WidgetClass
    -- ^ /@widgetClass@/: a widget class
    -> a
    -- ^ /@scope@/: @GtkBuilderScope@ to use when loading
    --   the class template
    -> m ()
widgetClassSetTemplateScope :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilderScope a) =>
WidgetClass -> a -> m ()
widgetClassSetTemplateScope WidgetClass
widgetClass a
scope = 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
    widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    scope' <- unsafeManagedPtrCastPtr scope
    gtk_widget_class_set_template_scope widgetClass' scope'
    touchManagedPtr widgetClass
    touchManagedPtr scope
    return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetTemplateScopeMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, Gtk.BuilderScope.IsBuilderScope a) => O.OverloadedMethod WidgetClassSetTemplateScopeMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetTemplateScope

instance O.OverloadedMethodInfo WidgetClassSetTemplateScopeMethodInfo WidgetClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateScope",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetTemplateScope"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveWidgetClassMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveWidgetClassMethod "addShortcut" o = WidgetClassAddShortcutMethodInfo
    ResolveWidgetClassMethod "bindTemplateCallbackFull" o = WidgetClassBindTemplateCallbackFullMethodInfo
    ResolveWidgetClassMethod "bindTemplateChildFull" o = WidgetClassBindTemplateChildFullMethodInfo
    ResolveWidgetClassMethod "installAction" o = WidgetClassInstallActionMethodInfo
    ResolveWidgetClassMethod "installPropertyAction" o = WidgetClassInstallPropertyActionMethodInfo
    ResolveWidgetClassMethod "queryAction" o = WidgetClassQueryActionMethodInfo
    ResolveWidgetClassMethod "getAccessibleRole" o = WidgetClassGetAccessibleRoleMethodInfo
    ResolveWidgetClassMethod "getActivateSignal" o = WidgetClassGetActivateSignalMethodInfo
    ResolveWidgetClassMethod "getCssName" o = WidgetClassGetCssNameMethodInfo
    ResolveWidgetClassMethod "getLayoutManagerType" o = WidgetClassGetLayoutManagerTypeMethodInfo
    ResolveWidgetClassMethod "setAccessibleRole" o = WidgetClassSetAccessibleRoleMethodInfo
    ResolveWidgetClassMethod "setActivateSignal" o = WidgetClassSetActivateSignalMethodInfo
    ResolveWidgetClassMethod "setActivateSignalFromName" o = WidgetClassSetActivateSignalFromNameMethodInfo
    ResolveWidgetClassMethod "setCssName" o = WidgetClassSetCssNameMethodInfo
    ResolveWidgetClassMethod "setLayoutManagerType" o = WidgetClassSetLayoutManagerTypeMethodInfo
    ResolveWidgetClassMethod "setTemplate" o = WidgetClassSetTemplateMethodInfo
    ResolveWidgetClassMethod "setTemplateFromResource" o = WidgetClassSetTemplateFromResourceMethodInfo
    ResolveWidgetClassMethod "setTemplateScope" o = WidgetClassSetTemplateScopeMethodInfo
    ResolveWidgetClassMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveWidgetClassMethod t WidgetClass, O.OverloadedMethod info WidgetClass p) => OL.IsLabel t (WidgetClass -> 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 ~ ResolveWidgetClassMethod t WidgetClass, O.OverloadedMethod info WidgetClass p, R.HasField t WidgetClass p) => R.HasField t WidgetClass p where
    getField = O.overloadedMethod @info

#endif

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

#endif