{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveWidgetClassMethod                ,
#endif


-- ** bindTemplateCallbackFull #method:bindTemplateCallbackFull#

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


-- ** bindTemplateChildFull #method:bindTemplateChildFull#

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


-- ** findStyleProperty #method:findStyleProperty#

#if defined(ENABLE_OVERLOADING)
    WidgetClassFindStylePropertyMethodInfo  ,
#endif
    widgetClassFindStyleProperty            ,


-- ** getCssName #method:getCssName#

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


-- ** installStyleProperty #method:installStyleProperty#

#if defined(ENABLE_OVERLOADING)
    WidgetClassInstallStylePropertyMethodInfo,
#endif
    widgetClassInstallStyleProperty         ,


-- ** setAccessibleRole #method:setAccessibleRole#

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


-- ** setAccessibleType #method:setAccessibleType#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetAccessibleTypeMethodInfo  ,
#endif
    widgetClassSetAccessibleType            ,


-- ** setConnectFunc #method:setConnectFunc#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetConnectFuncMethodInfo     ,
#endif
    widgetClassSetConnectFunc               ,


-- ** setCssName #method:setCssName#

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


-- ** setTemplate #method:setTemplate#

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


-- ** setTemplateFromResource #method:setTemplateFromResource#

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




 -- * Properties
-- ** activateSignal #attr:activateSignal#
-- | The signal to emit when a widget of this class is
--   activated, 'GI.Gtk.Objects.Widget.widgetActivate' handles the emission.
--   Implementation of this signal is optional.

    getWidgetClassActivateSignal            ,
    setWidgetClassActivateSignal            ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_activateSignal              ,
#endif


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

    clearWidgetClassAdjustBaselineAllocation,
    getWidgetClassAdjustBaselineAllocation  ,
    setWidgetClassAdjustBaselineAllocation  ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_adjustBaselineAllocation    ,
#endif


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

    clearWidgetClassAdjustBaselineRequest   ,
    getWidgetClassAdjustBaselineRequest     ,
    setWidgetClassAdjustBaselineRequest     ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_adjustBaselineRequest       ,
#endif


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

    clearWidgetClassAdjustSizeAllocation    ,
    getWidgetClassAdjustSizeAllocation      ,
    setWidgetClassAdjustSizeAllocation      ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_adjustSizeAllocation        ,
#endif


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

    clearWidgetClassAdjustSizeRequest       ,
    getWidgetClassAdjustSizeRequest         ,
    setWidgetClassAdjustSizeRequest         ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_adjustSizeRequest           ,
#endif


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

    clearWidgetClassButtonPressEvent        ,
    getWidgetClassButtonPressEvent          ,
    setWidgetClassButtonPressEvent          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_buttonPressEvent            ,
#endif


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

    clearWidgetClassButtonReleaseEvent      ,
    getWidgetClassButtonReleaseEvent        ,
    setWidgetClassButtonReleaseEvent        ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_buttonReleaseEvent          ,
#endif


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

    clearWidgetClassCanActivateAccel        ,
    getWidgetClassCanActivateAccel          ,
    setWidgetClassCanActivateAccel          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_canActivateAccel            ,
#endif


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

    clearWidgetClassChildNotify             ,
    getWidgetClassChildNotify               ,
    setWidgetClassChildNotify               ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_childNotify                 ,
#endif


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

    clearWidgetClassCompositedChanged       ,
    getWidgetClassCompositedChanged         ,
    setWidgetClassCompositedChanged         ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_compositedChanged           ,
#endif


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

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


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

    clearWidgetClassConfigureEvent          ,
    getWidgetClassConfigureEvent            ,
    setWidgetClassConfigureEvent            ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_configureEvent              ,
#endif


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

    clearWidgetClassDamageEvent             ,
    getWidgetClassDamageEvent               ,
    setWidgetClassDamageEvent               ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_damageEvent                 ,
#endif


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

    clearWidgetClassDeleteEvent             ,
    getWidgetClassDeleteEvent               ,
    setWidgetClassDeleteEvent               ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_deleteEvent                 ,
#endif


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

    clearWidgetClassDestroy                 ,
    getWidgetClassDestroy                   ,
    setWidgetClassDestroy                   ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_destroy                     ,
#endif


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

    clearWidgetClassDestroyEvent            ,
    getWidgetClassDestroyEvent              ,
    setWidgetClassDestroyEvent              ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_destroyEvent                ,
#endif


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

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


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

    clearWidgetClassDispatchChildPropertiesChanged,
    getWidgetClassDispatchChildPropertiesChanged,
    setWidgetClassDispatchChildPropertiesChanged,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dispatchChildPropertiesChanged,
#endif


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

    clearWidgetClassDragBegin               ,
    getWidgetClassDragBegin                 ,
    setWidgetClassDragBegin                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragBegin                   ,
#endif


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

    clearWidgetClassDragDataDelete          ,
    getWidgetClassDragDataDelete            ,
    setWidgetClassDragDataDelete            ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragDataDelete              ,
#endif


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

    clearWidgetClassDragDataGet             ,
    getWidgetClassDragDataGet               ,
    setWidgetClassDragDataGet               ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragDataGet                 ,
#endif


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

    clearWidgetClassDragDataReceived        ,
    getWidgetClassDragDataReceived          ,
    setWidgetClassDragDataReceived          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragDataReceived            ,
#endif


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

    clearWidgetClassDragDrop                ,
    getWidgetClassDragDrop                  ,
    setWidgetClassDragDrop                  ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragDrop                    ,
#endif


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

    clearWidgetClassDragEnd                 ,
    getWidgetClassDragEnd                   ,
    setWidgetClassDragEnd                   ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragEnd                     ,
#endif


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

    clearWidgetClassDragFailed              ,
    getWidgetClassDragFailed                ,
    setWidgetClassDragFailed                ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragFailed                  ,
#endif


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

    clearWidgetClassDragLeave               ,
    getWidgetClassDragLeave                 ,
    setWidgetClassDragLeave                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragLeave                   ,
#endif


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

    clearWidgetClassDragMotion              ,
    getWidgetClassDragMotion                ,
    setWidgetClassDragMotion                ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragMotion                  ,
#endif


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

    clearWidgetClassDraw                    ,
    getWidgetClassDraw                      ,
    setWidgetClassDraw                      ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_draw                        ,
#endif


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

    clearWidgetClassEnterNotifyEvent        ,
    getWidgetClassEnterNotifyEvent          ,
    setWidgetClassEnterNotifyEvent          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_enterNotifyEvent            ,
#endif


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

    clearWidgetClassEvent                   ,
    getWidgetClassEvent                     ,
    setWidgetClassEvent                     ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_event                       ,
#endif


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

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


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

    clearWidgetClassFocusInEvent            ,
    getWidgetClassFocusInEvent              ,
    setWidgetClassFocusInEvent              ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_focusInEvent                ,
#endif


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

    clearWidgetClassFocusOutEvent           ,
    getWidgetClassFocusOutEvent             ,
    setWidgetClassFocusOutEvent             ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_focusOutEvent               ,
#endif


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

    clearWidgetClassGetAccessible           ,
    getWidgetClassGetAccessible             ,
    setWidgetClassGetAccessible             ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_getAccessible               ,
#endif


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

    clearWidgetClassGetPreferredHeight      ,
    getWidgetClassGetPreferredHeight        ,
    setWidgetClassGetPreferredHeight        ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_getPreferredHeight          ,
#endif


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

    clearWidgetClassGetPreferredHeightAndBaselineForWidth,
    getWidgetClassGetPreferredHeightAndBaselineForWidth,
    setWidgetClassGetPreferredHeightAndBaselineForWidth,
#if defined(ENABLE_OVERLOADING)
    widgetClass_getPreferredHeightAndBaselineForWidth,
#endif


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

    clearWidgetClassGetPreferredHeightForWidth,
    getWidgetClassGetPreferredHeightForWidth,
    setWidgetClassGetPreferredHeightForWidth,
#if defined(ENABLE_OVERLOADING)
    widgetClass_getPreferredHeightForWidth  ,
#endif


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

    clearWidgetClassGetPreferredWidth       ,
    getWidgetClassGetPreferredWidth         ,
    setWidgetClassGetPreferredWidth         ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_getPreferredWidth           ,
#endif


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

    clearWidgetClassGetPreferredWidthForHeight,
    getWidgetClassGetPreferredWidthForHeight,
    setWidgetClassGetPreferredWidthForHeight,
#if defined(ENABLE_OVERLOADING)
    widgetClass_getPreferredWidthForHeight  ,
#endif


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

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


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

    clearWidgetClassGrabBrokenEvent         ,
    getWidgetClassGrabBrokenEvent           ,
    setWidgetClassGrabBrokenEvent           ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_grabBrokenEvent             ,
#endif


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

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


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

    clearWidgetClassGrabNotify              ,
    getWidgetClassGrabNotify                ,
    setWidgetClassGrabNotify                ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_grabNotify                  ,
#endif


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

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


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

    clearWidgetClassHierarchyChanged        ,
    getWidgetClassHierarchyChanged          ,
    setWidgetClassHierarchyChanged          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_hierarchyChanged            ,
#endif


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

    clearWidgetClassKeyPressEvent           ,
    getWidgetClassKeyPressEvent             ,
    setWidgetClassKeyPressEvent             ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_keyPressEvent               ,
#endif


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

    clearWidgetClassKeyReleaseEvent         ,
    getWidgetClassKeyReleaseEvent           ,
    setWidgetClassKeyReleaseEvent           ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_keyReleaseEvent             ,
#endif


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

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


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

    clearWidgetClassLeaveNotifyEvent        ,
    getWidgetClassLeaveNotifyEvent          ,
    setWidgetClassLeaveNotifyEvent          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_leaveNotifyEvent            ,
#endif


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

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


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

    clearWidgetClassMapEvent                ,
    getWidgetClassMapEvent                  ,
    setWidgetClassMapEvent                  ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_mapEvent                    ,
#endif


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

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


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

    clearWidgetClassMotionNotifyEvent       ,
    getWidgetClassMotionNotifyEvent         ,
    setWidgetClassMotionNotifyEvent         ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_motionNotifyEvent           ,
#endif


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

    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


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

    clearWidgetClassParentSet               ,
    getWidgetClassParentSet                 ,
    setWidgetClassParentSet                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_parentSet                   ,
#endif


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

    clearWidgetClassPopupMenu               ,
    getWidgetClassPopupMenu                 ,
    setWidgetClassPopupMenu                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_popupMenu                   ,
#endif


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

    clearWidgetClassPropertyNotifyEvent     ,
    getWidgetClassPropertyNotifyEvent       ,
    setWidgetClassPropertyNotifyEvent       ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_propertyNotifyEvent         ,
#endif


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

    clearWidgetClassProximityInEvent        ,
    getWidgetClassProximityInEvent          ,
    setWidgetClassProximityInEvent          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_proximityInEvent            ,
#endif


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

    clearWidgetClassProximityOutEvent       ,
    getWidgetClassProximityOutEvent         ,
    setWidgetClassProximityOutEvent         ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_proximityOutEvent           ,
#endif


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

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


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

    clearWidgetClassQueueDrawRegion         ,
    getWidgetClassQueueDrawRegion           ,
    setWidgetClassQueueDrawRegion           ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_queueDrawRegion             ,
#endif


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

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


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

    clearWidgetClassScreenChanged           ,
    getWidgetClassScreenChanged             ,
    setWidgetClassScreenChanged             ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_screenChanged               ,
#endif


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

    clearWidgetClassScrollEvent             ,
    getWidgetClassScrollEvent               ,
    setWidgetClassScrollEvent               ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_scrollEvent                 ,
#endif


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

    clearWidgetClassSelectionClearEvent     ,
    getWidgetClassSelectionClearEvent       ,
    setWidgetClassSelectionClearEvent       ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_selectionClearEvent         ,
#endif


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

    clearWidgetClassSelectionGet            ,
    getWidgetClassSelectionGet              ,
    setWidgetClassSelectionGet              ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_selectionGet                ,
#endif


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

    clearWidgetClassSelectionNotifyEvent    ,
    getWidgetClassSelectionNotifyEvent      ,
    setWidgetClassSelectionNotifyEvent      ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_selectionNotifyEvent        ,
#endif


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

    clearWidgetClassSelectionReceived       ,
    getWidgetClassSelectionReceived         ,
    setWidgetClassSelectionReceived         ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_selectionReceived           ,
#endif


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

    clearWidgetClassSelectionRequestEvent   ,
    getWidgetClassSelectionRequestEvent     ,
    setWidgetClassSelectionRequestEvent     ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_selectionRequestEvent       ,
#endif


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

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


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

    clearWidgetClassShowAll                 ,
    getWidgetClassShowAll                   ,
    setWidgetClassShowAll                   ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_showAll                     ,
#endif


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

    clearWidgetClassShowHelp                ,
    getWidgetClassShowHelp                  ,
    setWidgetClassShowHelp                  ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_showHelp                    ,
#endif


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

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


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

    clearWidgetClassStateChanged            ,
    getWidgetClassStateChanged              ,
    setWidgetClassStateChanged              ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_stateChanged                ,
#endif


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

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


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

    clearWidgetClassStyleSet                ,
    getWidgetClassStyleSet                  ,
    setWidgetClassStyleSet                  ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_styleSet                    ,
#endif


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

    clearWidgetClassStyleUpdated            ,
    getWidgetClassStyleUpdated              ,
    setWidgetClassStyleUpdated              ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_styleUpdated                ,
#endif


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

    clearWidgetClassTouchEvent              ,
    getWidgetClassTouchEvent                ,
    setWidgetClassTouchEvent                ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_touchEvent                  ,
#endif


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

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


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

    clearWidgetClassUnmapEvent              ,
    getWidgetClassUnmapEvent                ,
    setWidgetClassUnmapEvent                ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_unmapEvent                  ,
#endif


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

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


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

    clearWidgetClassVisibilityNotifyEvent   ,
    getWidgetClassVisibilityNotifyEvent     ,
    setWidgetClassVisibilityNotifyEvent     ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_visibilityNotifyEvent       ,
#endif


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

    clearWidgetClassWindowStateEvent        ,
    getWidgetClassWindowStateEvent          ,
    setWidgetClassWindowStateEvent          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_windowStateEvent            ,
#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.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.Atk.Enums as Atk.Enums
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
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

-- | 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
/= :: WidgetClass -> WidgetClass -> Bool
$c/= :: WidgetClass -> WidgetClass -> Bool
== :: WidgetClass -> WidgetClass -> Bool
$c== :: 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
824 (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
824


-- | Construct a `WidgetClass` struct initialized to zero.
newZeroWidgetClass :: MonadIO m => m WidgetClass
newZeroWidgetClass :: m WidgetClass
newZeroWidgetClass = IO WidgetClass -> m WidgetClass
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 (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 :: (ManagedPtr WidgetClass -> WidgetClass)
-> [AttrOp WidgetClass tag] -> m WidgetClass
new ManagedPtr WidgetClass -> WidgetClass
_ [AttrOp WidgetClass tag]
attrs = do
        WidgetClass
o <- m WidgetClass
forall (m :: * -> *). MonadIO m => m WidgetClass
newZeroWidgetClass
        WidgetClass -> [AttrOp WidgetClass 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set WidgetClass
o [AttrOp WidgetClass tag]
[AttrOp WidgetClass 'AttrSet]
attrs
        WidgetClass -> m WidgetClass
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClass
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 :: WidgetClass -> m InitiallyUnownedClass
getWidgetClassParentClass WidgetClass
s = IO InitiallyUnownedClass -> m InitiallyUnownedClass
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)
    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
    InitiallyUnownedClass -> IO InitiallyUnownedClass
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClass
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

widgetClass_parentClass :: AttrLabelProxy "parentClass"
widgetClass_parentClass = AttrLabelProxy

#endif


-- | Get the value of the “@activate_signal@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #activateSignal
-- @
getWidgetClassActivateSignal :: MonadIO m => WidgetClass -> m Word32
getWidgetClassActivateSignal :: WidgetClass -> m Word32
getWidgetClassActivateSignal WidgetClass
s = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO Word32) -> IO Word32)
-> (Ptr WidgetClass -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) :: IO Word32
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@activate_signal@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #activateSignal 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassActivateSignal :: MonadIO m => WidgetClass -> Word32 -> m ()
setWidgetClassActivateSignal :: WidgetClass -> Word32 -> m ()
setWidgetClassActivateSignal WidgetClass
s Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data WidgetClassActivateSignalFieldInfo
instance AttrInfo WidgetClassActivateSignalFieldInfo where
    type AttrBaseTypeConstraint WidgetClassActivateSignalFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassActivateSignalFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint WidgetClassActivateSignalFieldInfo = (~) Word32
    type AttrTransferTypeConstraint WidgetClassActivateSignalFieldInfo = (~)Word32
    type AttrTransferType WidgetClassActivateSignalFieldInfo = Word32
    type AttrGetType WidgetClassActivateSignalFieldInfo = Word32
    type AttrLabel WidgetClassActivateSignalFieldInfo = "activate_signal"
    type AttrOrigin WidgetClassActivateSignalFieldInfo = WidgetClass
    attrGet = getWidgetClassActivateSignal
    attrSet = setWidgetClassActivateSignal
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

widgetClass_activateSignal :: AttrLabelProxy "activateSignal"
widgetClass_activateSignal = AttrLabelProxy

#endif


-- | Get the value of the “@dispatch_child_properties_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 #dispatchChildPropertiesChanged
-- @
getWidgetClassDispatchChildPropertiesChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDispatchChildPropertiesChangedFieldCallback)
getWidgetClassDispatchChildPropertiesChanged :: WidgetClass
-> m (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)
getWidgetClassDispatchChildPropertiesChanged WidgetClass
s = IO (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)
-> m (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)
 -> m (Maybe
         WidgetClassDispatchChildPropertiesChangedFieldCallback))
-> IO
     (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)
-> m (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO
         (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback))
-> IO
     (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO
       (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback))
 -> IO
      (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback))
-> (Ptr WidgetClass
    -> IO
         (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback))
-> IO
     (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
val <- Ptr
  (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
-> IO
     (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr
     (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
    Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback
result <- FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
-> (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
    -> IO WidgetClassDispatchChildPropertiesChangedFieldCallback)
-> IO
     (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
val ((FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
  -> IO WidgetClassDispatchChildPropertiesChangedFieldCallback)
 -> IO
      (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback))
-> (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
    -> IO WidgetClassDispatchChildPropertiesChangedFieldCallback)
-> IO
     (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
val' -> do
        let val'' :: WidgetClassDispatchChildPropertiesChangedFieldCallback
val'' = FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
-> WidgetClassDispatchChildPropertiesChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
-> a -> Word32 -> GParamSpec -> m ()
Gtk.Callbacks.dynamic_WidgetClassDispatchChildPropertiesChangedFieldCallback FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
val'
        WidgetClassDispatchChildPropertiesChangedFieldCallback
-> IO WidgetClassDispatchChildPropertiesChangedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDispatchChildPropertiesChangedFieldCallback
val''
    Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback
-> IO
     (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback
result

-- | Set the value of the “@dispatch_child_properties_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 [ #dispatchChildPropertiesChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDispatchChildPropertiesChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> m ()
setWidgetClassDispatchChildPropertiesChanged :: WidgetClass
-> FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
-> m ()
setWidgetClassDispatchChildPropertiesChanged WidgetClass
s FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
val = IO () -> m ()
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_WidgetClassDispatchChildPropertiesChangedFieldCallback)
-> FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr
     (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDispatchChildPropertiesChangedFieldCallback)

-- | Set the value of the “@dispatch_child_properties_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' #dispatchChildPropertiesChanged
-- @
clearWidgetClassDispatchChildPropertiesChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDispatchChildPropertiesChanged :: WidgetClass -> m ()
clearWidgetClassDispatchChildPropertiesChanged WidgetClass
s = IO () -> m ()
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_WidgetClassDispatchChildPropertiesChangedFieldCallback)
-> FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr
     (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDispatchChildPropertiesChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDispatchChildPropertiesChangedFieldInfo
instance AttrInfo WidgetClassDispatchChildPropertiesChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDispatchChildPropertiesChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDispatchChildPropertiesChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDispatchChildPropertiesChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDispatchChildPropertiesChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassDispatchChildPropertiesChangedFieldCallback
    type AttrTransferType WidgetClassDispatchChildPropertiesChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
    type AttrGetType WidgetClassDispatchChildPropertiesChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassDispatchChildPropertiesChangedFieldCallback
    type AttrLabel WidgetClassDispatchChildPropertiesChangedFieldInfo = "dispatch_child_properties_changed"
    type AttrOrigin WidgetClassDispatchChildPropertiesChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassDispatchChildPropertiesChanged
    attrSet = setWidgetClassDispatchChildPropertiesChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassDispatchChildPropertiesChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDispatchChildPropertiesChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassDispatchChildPropertiesChangedFieldCallback Nothing v)

widgetClass_dispatchChildPropertiesChanged :: AttrLabelProxy "dispatchChildPropertiesChanged"
widgetClass_dispatchChildPropertiesChanged = AttrLabelProxy

#endif


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

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

-- | Set the value of the “@destroy@” 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' #destroy
-- @
clearWidgetClassDestroy :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDestroy :: WidgetClass -> m ()
clearWidgetClassDestroy WidgetClass
s = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) (FunPtr C_WidgetClassDestroyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDestroyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDestroyFieldInfo
instance AttrInfo WidgetClassDestroyFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDestroyFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDestroyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDestroyFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDestroyFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDestroyFieldInfo = (~)Gtk.Callbacks.WidgetClassDestroyFieldCallback
    type AttrTransferType WidgetClassDestroyFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDestroyFieldCallback)
    type AttrGetType WidgetClassDestroyFieldInfo = Maybe Gtk.Callbacks.WidgetClassDestroyFieldCallback
    type AttrLabel WidgetClassDestroyFieldInfo = "destroy"
    type AttrOrigin WidgetClassDestroyFieldInfo = WidgetClass
    attrGet = getWidgetClassDestroy
    attrSet = setWidgetClassDestroy
    attrConstruct = undefined
    attrClear = clearWidgetClassDestroy
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDestroyFieldCallback (Gtk.Callbacks.wrap_WidgetClassDestroyFieldCallback Nothing v)

widgetClass_destroy :: AttrLabelProxy "destroy"
widgetClass_destroy = 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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassShow WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassShowFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassShow WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassShow WidgetClass
s = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) (FunPtr C_WidgetClassDestroyFieldCallback
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)

widgetClass_show :: AttrLabelProxy "show"
widgetClass_show = AttrLabelProxy

#endif


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

-- | Set the value of the “@show_all@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #showAll 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassShowAll :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassShowAllFieldCallback -> m ()
setWidgetClassShowAll :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassShowAll WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassShowAllFieldCallback)

-- | Set the value of the “@show_all@” 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' #showAll
-- @
clearWidgetClassShowAll :: MonadIO m => WidgetClass -> m ()
clearWidgetClassShowAll :: WidgetClass -> m ()
clearWidgetClassShowAll WidgetClass
s = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) (FunPtr C_WidgetClassDestroyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassShowAllFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassShowAllFieldInfo
instance AttrInfo WidgetClassShowAllFieldInfo where
    type AttrBaseTypeConstraint WidgetClassShowAllFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassShowAllFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassShowAllFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassShowAllFieldCallback)
    type AttrTransferTypeConstraint WidgetClassShowAllFieldInfo = (~)Gtk.Callbacks.WidgetClassShowAllFieldCallback
    type AttrTransferType WidgetClassShowAllFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassShowAllFieldCallback)
    type AttrGetType WidgetClassShowAllFieldInfo = Maybe Gtk.Callbacks.WidgetClassShowAllFieldCallback
    type AttrLabel WidgetClassShowAllFieldInfo = "show_all"
    type AttrOrigin WidgetClassShowAllFieldInfo = WidgetClass
    attrGet = getWidgetClassShowAll
    attrSet = setWidgetClassShowAll
    attrConstruct = undefined
    attrClear = clearWidgetClassShowAll
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassShowAllFieldCallback (Gtk.Callbacks.wrap_WidgetClassShowAllFieldCallback Nothing v)

widgetClass_showAll :: AttrLabelProxy "showAll"
widgetClass_showAll = 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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassHide WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassHideFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassHide WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassHide WidgetClass
s = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) (FunPtr C_WidgetClassDestroyFieldCallback
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)

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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassMap WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassMapFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassMap WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassMap WidgetClass
s = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_WidgetClassDestroyFieldCallback
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)

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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassUnmap WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnmapFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassUnmap WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassUnmap WidgetClass
s = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_WidgetClassDestroyFieldCallback
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)

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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassRealize WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassRealizeFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassRealize WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassRealize WidgetClass
s = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_WidgetClassDestroyFieldCallback
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)

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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassUnrealize WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnrealizeFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassUnrealize WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassUnrealize WidgetClass
s = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) (FunPtr C_WidgetClassDestroyFieldCallback
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)

widgetClass_unrealize :: AttrLabelProxy "unrealize"
widgetClass_unrealize = 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 :: WidgetClass -> m (Maybe WidgetClassSizeAllocateFieldCallback)
getWidgetClassSizeAllocate WidgetClass
s = IO (Maybe WidgetClassSizeAllocateFieldCallback)
-> m (Maybe WidgetClassSizeAllocateFieldCallback)
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
    FunPtr C_WidgetClassSizeAllocateFieldCallback
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
216) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)
    Maybe WidgetClassSizeAllocateFieldCallback
result <- FunPtr C_WidgetClassSizeAllocateFieldCallback
-> (FunPtr C_WidgetClassSizeAllocateFieldCallback
    -> IO WidgetClassSizeAllocateFieldCallback)
-> IO (Maybe WidgetClassSizeAllocateFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassSizeAllocateFieldCallback
val ((FunPtr C_WidgetClassSizeAllocateFieldCallback
  -> IO WidgetClassSizeAllocateFieldCallback)
 -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
-> (FunPtr C_WidgetClassSizeAllocateFieldCallback
    -> IO WidgetClassSizeAllocateFieldCallback)
-> IO (Maybe WidgetClassSizeAllocateFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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 -> Rectangle -> m ()
Gtk.Callbacks.dynamic_WidgetClassSizeAllocateFieldCallback FunPtr C_WidgetClassSizeAllocateFieldCallback
val'
        WidgetClassSizeAllocateFieldCallback
-> IO WidgetClassSizeAllocateFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSizeAllocateFieldCallback
val''
    Maybe WidgetClassSizeAllocateFieldCallback
-> IO (Maybe WidgetClassSizeAllocateFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassSizeAllocateFieldCallback
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 :: WidgetClass
-> FunPtr C_WidgetClassSizeAllocateFieldCallback -> m ()
setWidgetClassSizeAllocate WidgetClass
s FunPtr C_WidgetClassSizeAllocateFieldCallback
val = IO () -> m ()
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
216) (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 :: WidgetClass -> m ()
clearWidgetClassSizeAllocate WidgetClass
s = IO () -> m ()
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
216) (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)

widgetClass_sizeAllocate :: AttrLabelProxy "sizeAllocate"
widgetClass_sizeAllocate = AttrLabelProxy

#endif


-- | Get the value of the “@state_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 #stateChanged
-- @
getWidgetClassStateChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassStateChangedFieldCallback)
getWidgetClassStateChanged :: WidgetClass -> m (Maybe WidgetClassStateChangedFieldCallback)
getWidgetClassStateChanged WidgetClass
s = IO (Maybe WidgetClassStateChangedFieldCallback)
-> m (Maybe WidgetClassStateChangedFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassStateChangedFieldCallback)
 -> m (Maybe WidgetClassStateChangedFieldCallback))
-> IO (Maybe WidgetClassStateChangedFieldCallback)
-> m (Maybe WidgetClassStateChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassStateChangedFieldCallback))
-> IO (Maybe WidgetClassStateChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassStateChangedFieldCallback))
 -> IO (Maybe WidgetClassStateChangedFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassStateChangedFieldCallback))
-> IO (Maybe WidgetClassStateChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassStateChangedFieldCallback
val <- Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
-> IO (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
224) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassStateChangedFieldCallback)
    Maybe WidgetClassStateChangedFieldCallback
result <- FunPtr C_WidgetClassStateChangedFieldCallback
-> (FunPtr C_WidgetClassStateChangedFieldCallback
    -> IO WidgetClassStateChangedFieldCallback)
-> IO (Maybe WidgetClassStateChangedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStateChangedFieldCallback
val ((FunPtr C_WidgetClassStateChangedFieldCallback
  -> IO WidgetClassStateChangedFieldCallback)
 -> IO (Maybe WidgetClassStateChangedFieldCallback))
-> (FunPtr C_WidgetClassStateChangedFieldCallback
    -> IO WidgetClassStateChangedFieldCallback)
-> IO (Maybe WidgetClassStateChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStateChangedFieldCallback
val' -> do
        let val'' :: WidgetClassStateChangedFieldCallback
val'' = FunPtr C_WidgetClassStateChangedFieldCallback
-> WidgetClassStateChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateChangedFieldCallback
-> a -> StateType -> m ()
Gtk.Callbacks.dynamic_WidgetClassStateChangedFieldCallback FunPtr C_WidgetClassStateChangedFieldCallback
val'
        WidgetClassStateChangedFieldCallback
-> IO WidgetClassStateChangedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassStateChangedFieldCallback
val''
    Maybe WidgetClassStateChangedFieldCallback
-> IO (Maybe WidgetClassStateChangedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassStateChangedFieldCallback
result

-- | Set the value of the “@state_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 [ #stateChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassStateChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassStateChangedFieldCallback -> m ()
setWidgetClassStateChanged :: WidgetClass
-> FunPtr C_WidgetClassStateChangedFieldCallback -> m ()
setWidgetClassStateChanged WidgetClass
s FunPtr C_WidgetClassStateChangedFieldCallback
val = IO () -> m ()
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_WidgetClassStateChangedFieldCallback)
-> FunPtr C_WidgetClassStateChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
224) (FunPtr C_WidgetClassStateChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassStateChangedFieldCallback)

-- | Set the value of the “@state_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' #stateChanged
-- @
clearWidgetClassStateChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassStateChanged :: WidgetClass -> m ()
clearWidgetClassStateChanged WidgetClass
s = IO () -> m ()
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_WidgetClassStateChangedFieldCallback)
-> FunPtr C_WidgetClassStateChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
224) (FunPtr C_WidgetClassStateChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassStateChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassStateChangedFieldInfo
instance AttrInfo WidgetClassStateChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassStateChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassStateChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassStateChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassStateChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassStateChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassStateChangedFieldCallback
    type AttrTransferType WidgetClassStateChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassStateChangedFieldCallback)
    type AttrGetType WidgetClassStateChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassStateChangedFieldCallback
    type AttrLabel WidgetClassStateChangedFieldInfo = "state_changed"
    type AttrOrigin WidgetClassStateChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassStateChanged
    attrSet = setWidgetClassStateChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassStateChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassStateChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassStateChangedFieldCallback Nothing v)

widgetClass_stateChanged :: AttrLabelProxy "stateChanged"
widgetClass_stateChanged = 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 :: WidgetClass -> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
getWidgetClassStateFlagsChanged WidgetClass
s = IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
-> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
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
    FunPtr C_WidgetClassStateChangedFieldCallback
val <- Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
-> IO (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)
    Maybe WidgetClassStateFlagsChangedFieldCallback
result <- FunPtr C_WidgetClassStateChangedFieldCallback
-> (FunPtr C_WidgetClassStateChangedFieldCallback
    -> IO WidgetClassStateFlagsChangedFieldCallback)
-> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStateChangedFieldCallback
val ((FunPtr C_WidgetClassStateChangedFieldCallback
  -> IO WidgetClassStateFlagsChangedFieldCallback)
 -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
-> (FunPtr C_WidgetClassStateChangedFieldCallback
    -> IO WidgetClassStateFlagsChangedFieldCallback)
-> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStateChangedFieldCallback
val' -> do
        let val'' :: WidgetClassStateFlagsChangedFieldCallback
val'' = FunPtr C_WidgetClassStateChangedFieldCallback
-> WidgetClassStateFlagsChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateChangedFieldCallback
-> a -> [StateFlags] -> m ()
Gtk.Callbacks.dynamic_WidgetClassStateFlagsChangedFieldCallback FunPtr C_WidgetClassStateChangedFieldCallback
val'
        WidgetClassStateFlagsChangedFieldCallback
-> IO WidgetClassStateFlagsChangedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassStateFlagsChangedFieldCallback
val''
    Maybe WidgetClassStateFlagsChangedFieldCallback
-> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassStateFlagsChangedFieldCallback
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 :: WidgetClass
-> FunPtr C_WidgetClassStateChangedFieldCallback -> m ()
setWidgetClassStateFlagsChanged WidgetClass
s FunPtr C_WidgetClassStateChangedFieldCallback
val = IO () -> m ()
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_WidgetClassStateChangedFieldCallback)
-> FunPtr C_WidgetClassStateChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) (FunPtr C_WidgetClassStateChangedFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassStateFlagsChanged WidgetClass
s = IO () -> m ()
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_WidgetClassStateChangedFieldCallback)
-> FunPtr C_WidgetClassStateChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) (FunPtr C_WidgetClassStateChangedFieldCallback
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)

widgetClass_stateFlagsChanged :: AttrLabelProxy "stateFlagsChanged"
widgetClass_stateFlagsChanged = AttrLabelProxy

#endif


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

-- | Set the value of the “@parent_set@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #parentSet 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassParentSet :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassParentSetFieldCallback -> m ()
setWidgetClassParentSet :: WidgetClass -> FunPtr C_WidgetClassParentSetFieldCallback -> m ()
setWidgetClassParentSet WidgetClass
s FunPtr C_WidgetClassParentSetFieldCallback
val = IO () -> m ()
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_WidgetClassParentSetFieldCallback)
-> FunPtr C_WidgetClassParentSetFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassParentSetFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) (FunPtr C_WidgetClassParentSetFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassParentSetFieldCallback)

-- | Set the value of the “@parent_set@” 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' #parentSet
-- @
clearWidgetClassParentSet :: MonadIO m => WidgetClass -> m ()
clearWidgetClassParentSet :: WidgetClass -> m ()
clearWidgetClassParentSet WidgetClass
s = IO () -> m ()
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_WidgetClassParentSetFieldCallback)
-> FunPtr C_WidgetClassParentSetFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassParentSetFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) (FunPtr C_WidgetClassParentSetFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassParentSetFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassParentSetFieldInfo
instance AttrInfo WidgetClassParentSetFieldInfo where
    type AttrBaseTypeConstraint WidgetClassParentSetFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassParentSetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassParentSetFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassParentSetFieldCallback)
    type AttrTransferTypeConstraint WidgetClassParentSetFieldInfo = (~)Gtk.Callbacks.WidgetClassParentSetFieldCallback
    type AttrTransferType WidgetClassParentSetFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassParentSetFieldCallback)
    type AttrGetType WidgetClassParentSetFieldInfo = Maybe Gtk.Callbacks.WidgetClassParentSetFieldCallback
    type AttrLabel WidgetClassParentSetFieldInfo = "parent_set"
    type AttrOrigin WidgetClassParentSetFieldInfo = WidgetClass
    attrGet = getWidgetClassParentSet
    attrSet = setWidgetClassParentSet
    attrConstruct = undefined
    attrClear = clearWidgetClassParentSet
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassParentSetFieldCallback (Gtk.Callbacks.wrap_WidgetClassParentSetFieldCallback Nothing v)

widgetClass_parentSet :: AttrLabelProxy "parentSet"
widgetClass_parentSet = AttrLabelProxy

#endif


-- | Get the value of the “@hierarchy_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 #hierarchyChanged
-- @
getWidgetClassHierarchyChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassHierarchyChangedFieldCallback)
getWidgetClassHierarchyChanged :: WidgetClass -> m (Maybe WidgetClassParentSetFieldCallback)
getWidgetClassHierarchyChanged WidgetClass
s = IO (Maybe WidgetClassParentSetFieldCallback)
-> m (Maybe WidgetClassParentSetFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassParentSetFieldCallback)
 -> m (Maybe WidgetClassParentSetFieldCallback))
-> IO (Maybe WidgetClassParentSetFieldCallback)
-> m (Maybe WidgetClassParentSetFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassParentSetFieldCallback))
-> IO (Maybe WidgetClassParentSetFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassParentSetFieldCallback))
 -> IO (Maybe WidgetClassParentSetFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassParentSetFieldCallback))
-> IO (Maybe WidgetClassParentSetFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassParentSetFieldCallback
val <- Ptr (FunPtr C_WidgetClassParentSetFieldCallback)
-> IO (FunPtr C_WidgetClassParentSetFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassParentSetFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassHierarchyChangedFieldCallback)
    Maybe WidgetClassParentSetFieldCallback
result <- FunPtr C_WidgetClassParentSetFieldCallback
-> (FunPtr C_WidgetClassParentSetFieldCallback
    -> IO WidgetClassParentSetFieldCallback)
-> IO (Maybe WidgetClassParentSetFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassParentSetFieldCallback
val ((FunPtr C_WidgetClassParentSetFieldCallback
  -> IO WidgetClassParentSetFieldCallback)
 -> IO (Maybe WidgetClassParentSetFieldCallback))
-> (FunPtr C_WidgetClassParentSetFieldCallback
    -> IO WidgetClassParentSetFieldCallback)
-> IO (Maybe WidgetClassParentSetFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassParentSetFieldCallback
val' -> do
        let val'' :: WidgetClassParentSetFieldCallback
val'' = FunPtr C_WidgetClassParentSetFieldCallback
-> WidgetClassParentSetFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
FunPtr C_WidgetClassParentSetFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_WidgetClassHierarchyChangedFieldCallback FunPtr C_WidgetClassParentSetFieldCallback
val'
        WidgetClassParentSetFieldCallback
-> IO WidgetClassParentSetFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassParentSetFieldCallback
val''
    Maybe WidgetClassParentSetFieldCallback
-> IO (Maybe WidgetClassParentSetFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassParentSetFieldCallback
result

-- | Set the value of the “@hierarchy_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 [ #hierarchyChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassHierarchyChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassHierarchyChangedFieldCallback -> m ()
setWidgetClassHierarchyChanged :: WidgetClass -> FunPtr C_WidgetClassParentSetFieldCallback -> m ()
setWidgetClassHierarchyChanged WidgetClass
s FunPtr C_WidgetClassParentSetFieldCallback
val = IO () -> m ()
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_WidgetClassParentSetFieldCallback)
-> FunPtr C_WidgetClassParentSetFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassParentSetFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) (FunPtr C_WidgetClassParentSetFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassHierarchyChangedFieldCallback)

-- | Set the value of the “@hierarchy_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' #hierarchyChanged
-- @
clearWidgetClassHierarchyChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassHierarchyChanged :: WidgetClass -> m ()
clearWidgetClassHierarchyChanged WidgetClass
s = IO () -> m ()
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_WidgetClassParentSetFieldCallback)
-> FunPtr C_WidgetClassParentSetFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassParentSetFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) (FunPtr C_WidgetClassParentSetFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassHierarchyChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassHierarchyChangedFieldInfo
instance AttrInfo WidgetClassHierarchyChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassHierarchyChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassHierarchyChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassHierarchyChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassHierarchyChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassHierarchyChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassHierarchyChangedFieldCallback
    type AttrTransferType WidgetClassHierarchyChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassHierarchyChangedFieldCallback)
    type AttrGetType WidgetClassHierarchyChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassHierarchyChangedFieldCallback
    type AttrLabel WidgetClassHierarchyChangedFieldInfo = "hierarchy_changed"
    type AttrOrigin WidgetClassHierarchyChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassHierarchyChanged
    attrSet = setWidgetClassHierarchyChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassHierarchyChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassHierarchyChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassHierarchyChangedFieldCallback Nothing v)

widgetClass_hierarchyChanged :: AttrLabelProxy "hierarchyChanged"
widgetClass_hierarchyChanged = AttrLabelProxy

#endif


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

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

-- | Set the value of the “@style_set@” 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' #styleSet
-- @
clearWidgetClassStyleSet :: MonadIO m => WidgetClass -> m ()
clearWidgetClassStyleSet :: WidgetClass -> m ()
clearWidgetClassStyleSet WidgetClass
s = IO () -> m ()
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_WidgetClassStyleSetFieldCallback)
-> FunPtr C_WidgetClassStyleSetFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStyleSetFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) (FunPtr C_WidgetClassStyleSetFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassStyleSetFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassStyleSetFieldInfo
instance AttrInfo WidgetClassStyleSetFieldInfo where
    type AttrBaseTypeConstraint WidgetClassStyleSetFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassStyleSetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassStyleSetFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassStyleSetFieldCallback)
    type AttrTransferTypeConstraint WidgetClassStyleSetFieldInfo = (~)Gtk.Callbacks.WidgetClassStyleSetFieldCallback
    type AttrTransferType WidgetClassStyleSetFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassStyleSetFieldCallback)
    type AttrGetType WidgetClassStyleSetFieldInfo = Maybe Gtk.Callbacks.WidgetClassStyleSetFieldCallback
    type AttrLabel WidgetClassStyleSetFieldInfo = "style_set"
    type AttrOrigin WidgetClassStyleSetFieldInfo = WidgetClass
    attrGet = getWidgetClassStyleSet
    attrSet = setWidgetClassStyleSet
    attrConstruct = undefined
    attrClear = clearWidgetClassStyleSet
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassStyleSetFieldCallback (Gtk.Callbacks.wrap_WidgetClassStyleSetFieldCallback Nothing v)

widgetClass_styleSet :: AttrLabelProxy "styleSet"
widgetClass_styleSet = 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 :: WidgetClass -> m (Maybe WidgetClassDirectionChangedFieldCallback)
getWidgetClassDirectionChanged WidgetClass
s = IO (Maybe WidgetClassDirectionChangedFieldCallback)
-> m (Maybe WidgetClassDirectionChangedFieldCallback)
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
    FunPtr C_WidgetClassStateChangedFieldCallback
val <- Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
-> IO (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)
    Maybe WidgetClassDirectionChangedFieldCallback
result <- FunPtr C_WidgetClassStateChangedFieldCallback
-> (FunPtr C_WidgetClassStateChangedFieldCallback
    -> IO WidgetClassDirectionChangedFieldCallback)
-> IO (Maybe WidgetClassDirectionChangedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStateChangedFieldCallback
val ((FunPtr C_WidgetClassStateChangedFieldCallback
  -> IO WidgetClassDirectionChangedFieldCallback)
 -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
-> (FunPtr C_WidgetClassStateChangedFieldCallback
    -> IO WidgetClassDirectionChangedFieldCallback)
-> IO (Maybe WidgetClassDirectionChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStateChangedFieldCallback
val' -> do
        let val'' :: WidgetClassDirectionChangedFieldCallback
val'' = FunPtr C_WidgetClassStateChangedFieldCallback
-> WidgetClassDirectionChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateChangedFieldCallback
-> a -> TextDirection -> m ()
Gtk.Callbacks.dynamic_WidgetClassDirectionChangedFieldCallback FunPtr C_WidgetClassStateChangedFieldCallback
val'
        WidgetClassDirectionChangedFieldCallback
-> IO WidgetClassDirectionChangedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDirectionChangedFieldCallback
val''
    Maybe WidgetClassDirectionChangedFieldCallback
-> IO (Maybe WidgetClassDirectionChangedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDirectionChangedFieldCallback
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 :: WidgetClass
-> FunPtr C_WidgetClassStateChangedFieldCallback -> m ()
setWidgetClassDirectionChanged WidgetClass
s FunPtr C_WidgetClassStateChangedFieldCallback
val = IO () -> m ()
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_WidgetClassStateChangedFieldCallback)
-> FunPtr C_WidgetClassStateChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) (FunPtr C_WidgetClassStateChangedFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassDirectionChanged WidgetClass
s = IO () -> m ()
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_WidgetClassStateChangedFieldCallback)
-> FunPtr C_WidgetClassStateChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) (FunPtr C_WidgetClassStateChangedFieldCallback
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)

widgetClass_directionChanged :: AttrLabelProxy "directionChanged"
widgetClass_directionChanged = AttrLabelProxy

#endif


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

-- | Set the value of the “@grab_notify@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #grabNotify 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGrabNotify :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback -> m ()
setWidgetClassGrabNotify :: WidgetClass -> FunPtr C_WidgetClassGrabNotifyFieldCallback -> m ()
setWidgetClassGrabNotify WidgetClass
s FunPtr C_WidgetClassGrabNotifyFieldCallback
val = IO () -> m ()
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_WidgetClassGrabNotifyFieldCallback)
-> FunPtr C_WidgetClassGrabNotifyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) (FunPtr C_WidgetClassGrabNotifyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback)

-- | Set the value of the “@grab_notify@” 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' #grabNotify
-- @
clearWidgetClassGrabNotify :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabNotify :: WidgetClass -> m ()
clearWidgetClassGrabNotify WidgetClass
s = IO () -> m ()
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_WidgetClassGrabNotifyFieldCallback)
-> FunPtr C_WidgetClassGrabNotifyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) (FunPtr C_WidgetClassGrabNotifyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGrabNotifyFieldInfo
instance AttrInfo WidgetClassGrabNotifyFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGrabNotifyFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGrabNotifyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGrabNotifyFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGrabNotifyFieldInfo = (~)Gtk.Callbacks.WidgetClassGrabNotifyFieldCallback
    type AttrTransferType WidgetClassGrabNotifyFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback)
    type AttrGetType WidgetClassGrabNotifyFieldInfo = Maybe Gtk.Callbacks.WidgetClassGrabNotifyFieldCallback
    type AttrLabel WidgetClassGrabNotifyFieldInfo = "grab_notify"
    type AttrOrigin WidgetClassGrabNotifyFieldInfo = WidgetClass
    attrGet = getWidgetClassGrabNotify
    attrSet = setWidgetClassGrabNotify
    attrConstruct = undefined
    attrClear = clearWidgetClassGrabNotify
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGrabNotifyFieldCallback (Gtk.Callbacks.wrap_WidgetClassGrabNotifyFieldCallback Nothing v)

widgetClass_grabNotify :: AttrLabelProxy "grabNotify"
widgetClass_grabNotify = AttrLabelProxy

#endif


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

-- | Set the value of the “@child_notify@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #childNotify 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassChildNotify :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassChildNotifyFieldCallback -> m ()
setWidgetClassChildNotify :: WidgetClass -> FunPtr C_WidgetClassChildNotifyFieldCallback -> m ()
setWidgetClassChildNotify WidgetClass
s FunPtr C_WidgetClassChildNotifyFieldCallback
val = IO () -> m ()
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_WidgetClassChildNotifyFieldCallback)
-> FunPtr C_WidgetClassChildNotifyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassChildNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) (FunPtr C_WidgetClassChildNotifyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassChildNotifyFieldCallback)

-- | Set the value of the “@child_notify@” 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' #childNotify
-- @
clearWidgetClassChildNotify :: MonadIO m => WidgetClass -> m ()
clearWidgetClassChildNotify :: WidgetClass -> m ()
clearWidgetClassChildNotify WidgetClass
s = IO () -> m ()
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_WidgetClassChildNotifyFieldCallback)
-> FunPtr C_WidgetClassChildNotifyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassChildNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) (FunPtr C_WidgetClassChildNotifyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassChildNotifyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassChildNotifyFieldInfo
instance AttrInfo WidgetClassChildNotifyFieldInfo where
    type AttrBaseTypeConstraint WidgetClassChildNotifyFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassChildNotifyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassChildNotifyFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassChildNotifyFieldCallback)
    type AttrTransferTypeConstraint WidgetClassChildNotifyFieldInfo = (~)Gtk.Callbacks.WidgetClassChildNotifyFieldCallback
    type AttrTransferType WidgetClassChildNotifyFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassChildNotifyFieldCallback)
    type AttrGetType WidgetClassChildNotifyFieldInfo = Maybe Gtk.Callbacks.WidgetClassChildNotifyFieldCallback
    type AttrLabel WidgetClassChildNotifyFieldInfo = "child_notify"
    type AttrOrigin WidgetClassChildNotifyFieldInfo = WidgetClass
    attrGet = getWidgetClassChildNotify
    attrSet = setWidgetClassChildNotify
    attrConstruct = undefined
    attrClear = clearWidgetClassChildNotify
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassChildNotifyFieldCallback (Gtk.Callbacks.wrap_WidgetClassChildNotifyFieldCallback Nothing v)

widgetClass_childNotify :: AttrLabelProxy "childNotify"
widgetClass_childNotify = AttrLabelProxy

#endif


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

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

-- | Set the value of the “@draw@” 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' #draw
-- @
clearWidgetClassDraw :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDraw :: WidgetClass -> m ()
clearWidgetClassDraw WidgetClass
s = IO () -> m ()
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_WidgetClassDrawFieldCallback)
-> FunPtr C_WidgetClassDrawFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDrawFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
288) (FunPtr C_WidgetClassDrawFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDrawFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDrawFieldInfo
instance AttrInfo WidgetClassDrawFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDrawFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDrawFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDrawFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDrawFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDrawFieldInfo = (~)Gtk.Callbacks.WidgetClassDrawFieldCallback
    type AttrTransferType WidgetClassDrawFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDrawFieldCallback)
    type AttrGetType WidgetClassDrawFieldInfo = Maybe Gtk.Callbacks.WidgetClassDrawFieldCallback
    type AttrLabel WidgetClassDrawFieldInfo = "draw"
    type AttrOrigin WidgetClassDrawFieldInfo = WidgetClass
    attrGet = getWidgetClassDraw
    attrSet = setWidgetClassDraw
    attrConstruct = undefined
    attrClear = clearWidgetClassDraw
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDrawFieldCallback (Gtk.Callbacks.wrap_WidgetClassDrawFieldCallback Nothing v)

widgetClass_draw :: AttrLabelProxy "draw"
widgetClass_draw = 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 :: WidgetClass -> m (Maybe WidgetClassGetRequestModeFieldCallback)
getWidgetClassGetRequestMode WidgetClass
s = IO (Maybe WidgetClassGetRequestModeFieldCallback)
-> m (Maybe WidgetClassGetRequestModeFieldCallback)
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
    FunPtr C_WidgetClassGetRequestModeFieldCallback
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
296) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)
    Maybe WidgetClassGetRequestModeFieldCallback
result <- FunPtr C_WidgetClassGetRequestModeFieldCallback
-> (FunPtr C_WidgetClassGetRequestModeFieldCallback
    -> IO WidgetClassGetRequestModeFieldCallback)
-> IO (Maybe WidgetClassGetRequestModeFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassGetRequestModeFieldCallback
val ((FunPtr C_WidgetClassGetRequestModeFieldCallback
  -> IO WidgetClassGetRequestModeFieldCallback)
 -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
-> (FunPtr C_WidgetClassGetRequestModeFieldCallback
    -> IO WidgetClassGetRequestModeFieldCallback)
-> IO (Maybe WidgetClassGetRequestModeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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 (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGetRequestModeFieldCallback
val''
    Maybe WidgetClassGetRequestModeFieldCallback
-> IO (Maybe WidgetClassGetRequestModeFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGetRequestModeFieldCallback
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 :: WidgetClass
-> FunPtr C_WidgetClassGetRequestModeFieldCallback -> m ()
setWidgetClassGetRequestMode WidgetClass
s FunPtr C_WidgetClassGetRequestModeFieldCallback
val = IO () -> m ()
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
296) (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 :: WidgetClass -> m ()
clearWidgetClassGetRequestMode WidgetClass
s = IO () -> m ()
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
296) (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)

widgetClass_getRequestMode :: AttrLabelProxy "getRequestMode"
widgetClass_getRequestMode = AttrLabelProxy

#endif


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

-- | Set the value of the “@get_preferred_height@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #getPreferredHeight 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGetPreferredHeight :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightFieldCallback -> m ()
setWidgetClassGetPreferredHeight :: WidgetClass
-> FunPtr C_WidgetClassGetPreferredHeightFieldCallback -> m ()
setWidgetClassGetPreferredHeight WidgetClass
s FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val = IO () -> m ()
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_WidgetClassGetPreferredHeightFieldCallback)
-> FunPtr C_WidgetClassGetPreferredHeightFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetPreferredHeightFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
304) (FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightFieldCallback)

-- | Set the value of the “@get_preferred_height@” 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' #getPreferredHeight
-- @
clearWidgetClassGetPreferredHeight :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredHeight :: WidgetClass -> m ()
clearWidgetClassGetPreferredHeight WidgetClass
s = IO () -> m ()
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_WidgetClassGetPreferredHeightFieldCallback)
-> FunPtr C_WidgetClassGetPreferredHeightFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetPreferredHeightFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
304) (FunPtr C_WidgetClassGetPreferredHeightFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetPreferredHeightFieldInfo
instance AttrInfo WidgetClassGetPreferredHeightFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGetPreferredHeightFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGetPreferredHeightFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGetPreferredHeightFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGetPreferredHeightFieldInfo = (~)Gtk.Callbacks.WidgetClassGetPreferredHeightFieldCallback
    type AttrTransferType WidgetClassGetPreferredHeightFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightFieldCallback)
    type AttrGetType WidgetClassGetPreferredHeightFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetPreferredHeightFieldCallback
    type AttrLabel WidgetClassGetPreferredHeightFieldInfo = "get_preferred_height"
    type AttrOrigin WidgetClassGetPreferredHeightFieldInfo = WidgetClass
    attrGet = getWidgetClassGetPreferredHeight
    attrSet = setWidgetClassGetPreferredHeight
    attrConstruct = undefined
    attrClear = clearWidgetClassGetPreferredHeight
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGetPreferredHeightFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetPreferredHeightFieldCallback Nothing v)

widgetClass_getPreferredHeight :: AttrLabelProxy "getPreferredHeight"
widgetClass_getPreferredHeight = AttrLabelProxy

#endif


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

-- | Set the value of the “@get_preferred_width_for_height@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #getPreferredWidthForHeight 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGetPreferredWidthForHeight :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthForHeightFieldCallback -> m ()
setWidgetClassGetPreferredWidthForHeight :: WidgetClass
-> FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
-> m ()
setWidgetClassGetPreferredWidthForHeight WidgetClass
s FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val = IO () -> m ()
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_WidgetClassGetPreferredWidthForHeightFieldCallback)
-> FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr
     (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
312) (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthForHeightFieldCallback)

-- | Set the value of the “@get_preferred_width_for_height@” 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' #getPreferredWidthForHeight
-- @
clearWidgetClassGetPreferredWidthForHeight :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredWidthForHeight :: WidgetClass -> m ()
clearWidgetClassGetPreferredWidthForHeight WidgetClass
s = IO () -> m ()
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_WidgetClassGetPreferredWidthForHeightFieldCallback)
-> FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr
     (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
312) (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthForHeightFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetPreferredWidthForHeightFieldInfo
instance AttrInfo WidgetClassGetPreferredWidthForHeightFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGetPreferredWidthForHeightFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGetPreferredWidthForHeightFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGetPreferredWidthForHeightFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthForHeightFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGetPreferredWidthForHeightFieldInfo = (~)Gtk.Callbacks.WidgetClassGetPreferredWidthForHeightFieldCallback
    type AttrTransferType WidgetClassGetPreferredWidthForHeightFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthForHeightFieldCallback)
    type AttrGetType WidgetClassGetPreferredWidthForHeightFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetPreferredWidthForHeightFieldCallback
    type AttrLabel WidgetClassGetPreferredWidthForHeightFieldInfo = "get_preferred_width_for_height"
    type AttrOrigin WidgetClassGetPreferredWidthForHeightFieldInfo = WidgetClass
    attrGet = getWidgetClassGetPreferredWidthForHeight
    attrSet = setWidgetClassGetPreferredWidthForHeight
    attrConstruct = undefined
    attrClear = clearWidgetClassGetPreferredWidthForHeight
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGetPreferredWidthForHeightFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetPreferredWidthForHeightFieldCallback Nothing v)

widgetClass_getPreferredWidthForHeight :: AttrLabelProxy "getPreferredWidthForHeight"
widgetClass_getPreferredWidthForHeight = AttrLabelProxy

#endif


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

-- | Set the value of the “@get_preferred_width@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #getPreferredWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGetPreferredWidth :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthFieldCallback -> m ()
setWidgetClassGetPreferredWidth :: WidgetClass
-> FunPtr C_WidgetClassGetPreferredHeightFieldCallback -> m ()
setWidgetClassGetPreferredWidth WidgetClass
s FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val = IO () -> m ()
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_WidgetClassGetPreferredHeightFieldCallback)
-> FunPtr C_WidgetClassGetPreferredHeightFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetPreferredHeightFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
320) (FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthFieldCallback)

-- | Set the value of the “@get_preferred_width@” 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' #getPreferredWidth
-- @
clearWidgetClassGetPreferredWidth :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredWidth :: WidgetClass -> m ()
clearWidgetClassGetPreferredWidth WidgetClass
s = IO () -> m ()
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_WidgetClassGetPreferredHeightFieldCallback)
-> FunPtr C_WidgetClassGetPreferredHeightFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetPreferredHeightFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
320) (FunPtr C_WidgetClassGetPreferredHeightFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetPreferredWidthFieldInfo
instance AttrInfo WidgetClassGetPreferredWidthFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGetPreferredWidthFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGetPreferredWidthFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGetPreferredWidthFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGetPreferredWidthFieldInfo = (~)Gtk.Callbacks.WidgetClassGetPreferredWidthFieldCallback
    type AttrTransferType WidgetClassGetPreferredWidthFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthFieldCallback)
    type AttrGetType WidgetClassGetPreferredWidthFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetPreferredWidthFieldCallback
    type AttrLabel WidgetClassGetPreferredWidthFieldInfo = "get_preferred_width"
    type AttrOrigin WidgetClassGetPreferredWidthFieldInfo = WidgetClass
    attrGet = getWidgetClassGetPreferredWidth
    attrSet = setWidgetClassGetPreferredWidth
    attrConstruct = undefined
    attrClear = clearWidgetClassGetPreferredWidth
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGetPreferredWidthFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetPreferredWidthFieldCallback Nothing v)

widgetClass_getPreferredWidth :: AttrLabelProxy "getPreferredWidth"
widgetClass_getPreferredWidth = AttrLabelProxy

#endif


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

-- | Set the value of the “@get_preferred_height_for_width@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #getPreferredHeightForWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGetPreferredHeightForWidth :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightForWidthFieldCallback -> m ()
setWidgetClassGetPreferredHeightForWidth :: WidgetClass
-> FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
-> m ()
setWidgetClassGetPreferredHeightForWidth WidgetClass
s FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val = IO () -> m ()
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_WidgetClassGetPreferredWidthForHeightFieldCallback)
-> FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr
     (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
328) (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightForWidthFieldCallback)

-- | Set the value of the “@get_preferred_height_for_width@” 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' #getPreferredHeightForWidth
-- @
clearWidgetClassGetPreferredHeightForWidth :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredHeightForWidth :: WidgetClass -> m ()
clearWidgetClassGetPreferredHeightForWidth WidgetClass
s = IO () -> m ()
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_WidgetClassGetPreferredWidthForHeightFieldCallback)
-> FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr
     (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
328) (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightForWidthFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetPreferredHeightForWidthFieldInfo
instance AttrInfo WidgetClassGetPreferredHeightForWidthFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGetPreferredHeightForWidthFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGetPreferredHeightForWidthFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGetPreferredHeightForWidthFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightForWidthFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGetPreferredHeightForWidthFieldInfo = (~)Gtk.Callbacks.WidgetClassGetPreferredHeightForWidthFieldCallback
    type AttrTransferType WidgetClassGetPreferredHeightForWidthFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightForWidthFieldCallback)
    type AttrGetType WidgetClassGetPreferredHeightForWidthFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetPreferredHeightForWidthFieldCallback
    type AttrLabel WidgetClassGetPreferredHeightForWidthFieldInfo = "get_preferred_height_for_width"
    type AttrOrigin WidgetClassGetPreferredHeightForWidthFieldInfo = WidgetClass
    attrGet = getWidgetClassGetPreferredHeightForWidth
    attrSet = setWidgetClassGetPreferredHeightForWidth
    attrConstruct = undefined
    attrClear = clearWidgetClassGetPreferredHeightForWidth
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGetPreferredHeightForWidthFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetPreferredHeightForWidthFieldCallback Nothing v)

widgetClass_getPreferredHeightForWidth :: AttrLabelProxy "getPreferredHeightForWidth"
widgetClass_getPreferredHeightForWidth = 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 :: WidgetClass -> m (Maybe WidgetClassMnemonicActivateFieldCallback)
getWidgetClassMnemonicActivate WidgetClass
s = IO (Maybe WidgetClassMnemonicActivateFieldCallback)
-> m (Maybe WidgetClassMnemonicActivateFieldCallback)
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
    FunPtr C_WidgetClassMnemonicActivateFieldCallback
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
336) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)
    Maybe WidgetClassMnemonicActivateFieldCallback
result <- FunPtr C_WidgetClassMnemonicActivateFieldCallback
-> (FunPtr C_WidgetClassMnemonicActivateFieldCallback
    -> IO WidgetClassMnemonicActivateFieldCallback)
-> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassMnemonicActivateFieldCallback
val ((FunPtr C_WidgetClassMnemonicActivateFieldCallback
  -> IO WidgetClassMnemonicActivateFieldCallback)
 -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
-> (FunPtr C_WidgetClassMnemonicActivateFieldCallback
    -> IO WidgetClassMnemonicActivateFieldCallback)
-> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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 (m :: * -> *) a. Monad m => a -> m a
return WidgetClassMnemonicActivateFieldCallback
val''
    Maybe WidgetClassMnemonicActivateFieldCallback
-> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassMnemonicActivateFieldCallback
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 :: WidgetClass
-> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> m ()
setWidgetClassMnemonicActivate WidgetClass
s FunPtr C_WidgetClassMnemonicActivateFieldCallback
val = IO () -> m ()
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
336) (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 :: WidgetClass -> m ()
clearWidgetClassMnemonicActivate WidgetClass
s = IO () -> m ()
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
336) (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)

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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassGrabFocus WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
344) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassGrabFocusFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassGrabFocus WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
344) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassGrabFocus WidgetClass
s = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
344) (FunPtr C_WidgetClassDestroyFieldCallback
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)

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 :: WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)
getWidgetClassFocus WidgetClass
s = IO (Maybe WidgetClassFocusFieldCallback)
-> m (Maybe WidgetClassFocusFieldCallback)
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
    FunPtr C_WidgetClassFocusFieldCallback
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
352) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)
    Maybe WidgetClassFocusFieldCallback
result <- FunPtr C_WidgetClassFocusFieldCallback
-> (FunPtr C_WidgetClassFocusFieldCallback
    -> IO WidgetClassFocusFieldCallback)
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassFocusFieldCallback
val ((FunPtr C_WidgetClassFocusFieldCallback
  -> IO WidgetClassFocusFieldCallback)
 -> IO (Maybe WidgetClassFocusFieldCallback))
-> (FunPtr C_WidgetClassFocusFieldCallback
    -> IO WidgetClassFocusFieldCallback)
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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 (m :: * -> *) a. Monad m => a -> m a
return WidgetClassFocusFieldCallback
val''
    Maybe WidgetClassFocusFieldCallback
-> IO (Maybe WidgetClassFocusFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassFocusFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassFocus WidgetClass
s FunPtr C_WidgetClassFocusFieldCallback
val = IO () -> m ()
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
352) (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 :: WidgetClass -> m ()
clearWidgetClassFocus WidgetClass
s = IO () -> m ()
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
352) (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)

widgetClass_focus :: AttrLabelProxy "focus"
widgetClass_focus = 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 :: WidgetClass -> m (Maybe WidgetClassMoveFocusFieldCallback)
getWidgetClassMoveFocus WidgetClass
s = IO (Maybe WidgetClassMoveFocusFieldCallback)
-> m (Maybe WidgetClassMoveFocusFieldCallback)
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
    FunPtr C_WidgetClassStateChangedFieldCallback
val <- Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
-> IO (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
360) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)
    Maybe WidgetClassMoveFocusFieldCallback
result <- FunPtr C_WidgetClassStateChangedFieldCallback
-> (FunPtr C_WidgetClassStateChangedFieldCallback
    -> IO WidgetClassMoveFocusFieldCallback)
-> IO (Maybe WidgetClassMoveFocusFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStateChangedFieldCallback
val ((FunPtr C_WidgetClassStateChangedFieldCallback
  -> IO WidgetClassMoveFocusFieldCallback)
 -> IO (Maybe WidgetClassMoveFocusFieldCallback))
-> (FunPtr C_WidgetClassStateChangedFieldCallback
    -> IO WidgetClassMoveFocusFieldCallback)
-> IO (Maybe WidgetClassMoveFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStateChangedFieldCallback
val' -> do
        let val'' :: WidgetClassMoveFocusFieldCallback
val'' = FunPtr C_WidgetClassStateChangedFieldCallback
-> WidgetClassMoveFocusFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateChangedFieldCallback
-> a -> DirectionType -> m ()
Gtk.Callbacks.dynamic_WidgetClassMoveFocusFieldCallback FunPtr C_WidgetClassStateChangedFieldCallback
val'
        WidgetClassMoveFocusFieldCallback
-> IO WidgetClassMoveFocusFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassMoveFocusFieldCallback
val''
    Maybe WidgetClassMoveFocusFieldCallback
-> IO (Maybe WidgetClassMoveFocusFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassMoveFocusFieldCallback
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 :: WidgetClass
-> FunPtr C_WidgetClassStateChangedFieldCallback -> m ()
setWidgetClassMoveFocus WidgetClass
s FunPtr C_WidgetClassStateChangedFieldCallback
val = IO () -> m ()
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_WidgetClassStateChangedFieldCallback)
-> FunPtr C_WidgetClassStateChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
360) (FunPtr C_WidgetClassStateChangedFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassMoveFocus WidgetClass
s = IO () -> m ()
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_WidgetClassStateChangedFieldCallback)
-> FunPtr C_WidgetClassStateChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
360) (FunPtr C_WidgetClassStateChangedFieldCallback
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)

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 :: WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)
getWidgetClassKeynavFailed WidgetClass
s = IO (Maybe WidgetClassFocusFieldCallback)
-> m (Maybe WidgetClassFocusFieldCallback)
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
    FunPtr C_WidgetClassFocusFieldCallback
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
368) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)
    Maybe WidgetClassFocusFieldCallback
result <- FunPtr C_WidgetClassFocusFieldCallback
-> (FunPtr C_WidgetClassFocusFieldCallback
    -> IO WidgetClassFocusFieldCallback)
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassFocusFieldCallback
val ((FunPtr C_WidgetClassFocusFieldCallback
  -> IO WidgetClassFocusFieldCallback)
 -> IO (Maybe WidgetClassFocusFieldCallback))
-> (FunPtr C_WidgetClassFocusFieldCallback
    -> IO WidgetClassFocusFieldCallback)
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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 (m :: * -> *) a. Monad m => a -> m a
return WidgetClassFocusFieldCallback
val''
    Maybe WidgetClassFocusFieldCallback
-> IO (Maybe WidgetClassFocusFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassFocusFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassKeynavFailed WidgetClass
s FunPtr C_WidgetClassFocusFieldCallback
val = IO () -> m ()
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
368) (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 :: WidgetClass -> m ()
clearWidgetClassKeynavFailed WidgetClass
s = IO () -> m ()
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
368) (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)

widgetClass_keynavFailed :: AttrLabelProxy "keynavFailed"
widgetClass_keynavFailed = AttrLabelProxy

#endif


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

-- | Set the value of the “@event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #event 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassEventFieldCallback -> m ()
setWidgetClassEvent :: WidgetClass -> FunPtr C_WidgetClassEventFieldCallback -> m ()
setWidgetClassEvent WidgetClass
s FunPtr C_WidgetClassEventFieldCallback
val = IO () -> m ()
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_WidgetClassEventFieldCallback)
-> FunPtr C_WidgetClassEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
376) (FunPtr C_WidgetClassEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassEventFieldCallback)

-- | Set the value of the “@event@” 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' #event
-- @
clearWidgetClassEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassEvent :: WidgetClass -> m ()
clearWidgetClassEvent WidgetClass
s = IO () -> m ()
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_WidgetClassEventFieldCallback)
-> FunPtr C_WidgetClassEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
376) (FunPtr C_WidgetClassEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassEventFieldInfo
instance AttrInfo WidgetClassEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassEventFieldInfo = (~)Gtk.Callbacks.WidgetClassEventFieldCallback
    type AttrTransferType WidgetClassEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassEventFieldCallback)
    type AttrGetType WidgetClassEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassEventFieldCallback
    type AttrLabel WidgetClassEventFieldInfo = "event"
    type AttrOrigin WidgetClassEventFieldInfo = WidgetClass
    attrGet = getWidgetClassEvent
    attrSet = setWidgetClassEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassEventFieldCallback Nothing v)

widgetClass_event :: AttrLabelProxy "event"
widgetClass_event = AttrLabelProxy

#endif


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

-- | Set the value of the “@button_press_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #buttonPressEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassButtonPressEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassButtonPressEventFieldCallback -> m ()
setWidgetClassButtonPressEvent :: WidgetClass
-> FunPtr C_WidgetClassButtonPressEventFieldCallback -> m ()
setWidgetClassButtonPressEvent WidgetClass
s FunPtr C_WidgetClassButtonPressEventFieldCallback
val = IO () -> m ()
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_WidgetClassButtonPressEventFieldCallback)
-> FunPtr C_WidgetClassButtonPressEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassButtonPressEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
384) (FunPtr C_WidgetClassButtonPressEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassButtonPressEventFieldCallback)

-- | Set the value of the “@button_press_event@” 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' #buttonPressEvent
-- @
clearWidgetClassButtonPressEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassButtonPressEvent :: WidgetClass -> m ()
clearWidgetClassButtonPressEvent WidgetClass
s = IO () -> m ()
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_WidgetClassButtonPressEventFieldCallback)
-> FunPtr C_WidgetClassButtonPressEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassButtonPressEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
384) (FunPtr C_WidgetClassButtonPressEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassButtonPressEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassButtonPressEventFieldInfo
instance AttrInfo WidgetClassButtonPressEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassButtonPressEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassButtonPressEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassButtonPressEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassButtonPressEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassButtonPressEventFieldInfo = (~)Gtk.Callbacks.WidgetClassButtonPressEventFieldCallback
    type AttrTransferType WidgetClassButtonPressEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassButtonPressEventFieldCallback)
    type AttrGetType WidgetClassButtonPressEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassButtonPressEventFieldCallback
    type AttrLabel WidgetClassButtonPressEventFieldInfo = "button_press_event"
    type AttrOrigin WidgetClassButtonPressEventFieldInfo = WidgetClass
    attrGet = getWidgetClassButtonPressEvent
    attrSet = setWidgetClassButtonPressEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassButtonPressEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassButtonPressEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassButtonPressEventFieldCallback Nothing v)

widgetClass_buttonPressEvent :: AttrLabelProxy "buttonPressEvent"
widgetClass_buttonPressEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@button_release_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #buttonReleaseEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassButtonReleaseEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassButtonReleaseEventFieldCallback -> m ()
setWidgetClassButtonReleaseEvent :: WidgetClass
-> FunPtr C_WidgetClassButtonPressEventFieldCallback -> m ()
setWidgetClassButtonReleaseEvent WidgetClass
s FunPtr C_WidgetClassButtonPressEventFieldCallback
val = IO () -> m ()
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_WidgetClassButtonPressEventFieldCallback)
-> FunPtr C_WidgetClassButtonPressEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassButtonPressEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
392) (FunPtr C_WidgetClassButtonPressEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassButtonReleaseEventFieldCallback)

-- | Set the value of the “@button_release_event@” 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' #buttonReleaseEvent
-- @
clearWidgetClassButtonReleaseEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassButtonReleaseEvent :: WidgetClass -> m ()
clearWidgetClassButtonReleaseEvent WidgetClass
s = IO () -> m ()
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_WidgetClassButtonPressEventFieldCallback)
-> FunPtr C_WidgetClassButtonPressEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassButtonPressEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
392) (FunPtr C_WidgetClassButtonPressEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassButtonReleaseEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassButtonReleaseEventFieldInfo
instance AttrInfo WidgetClassButtonReleaseEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassButtonReleaseEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassButtonReleaseEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassButtonReleaseEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassButtonReleaseEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassButtonReleaseEventFieldInfo = (~)Gtk.Callbacks.WidgetClassButtonReleaseEventFieldCallback
    type AttrTransferType WidgetClassButtonReleaseEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassButtonReleaseEventFieldCallback)
    type AttrGetType WidgetClassButtonReleaseEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassButtonReleaseEventFieldCallback
    type AttrLabel WidgetClassButtonReleaseEventFieldInfo = "button_release_event"
    type AttrOrigin WidgetClassButtonReleaseEventFieldInfo = WidgetClass
    attrGet = getWidgetClassButtonReleaseEvent
    attrSet = setWidgetClassButtonReleaseEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassButtonReleaseEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassButtonReleaseEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassButtonReleaseEventFieldCallback Nothing v)

widgetClass_buttonReleaseEvent :: AttrLabelProxy "buttonReleaseEvent"
widgetClass_buttonReleaseEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@scroll_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #scrollEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassScrollEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassScrollEventFieldCallback -> m ()
setWidgetClassScrollEvent :: WidgetClass -> FunPtr C_WidgetClassScrollEventFieldCallback -> m ()
setWidgetClassScrollEvent WidgetClass
s FunPtr C_WidgetClassScrollEventFieldCallback
val = IO () -> m ()
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_WidgetClassScrollEventFieldCallback)
-> FunPtr C_WidgetClassScrollEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassScrollEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
400) (FunPtr C_WidgetClassScrollEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassScrollEventFieldCallback)

-- | Set the value of the “@scroll_event@” 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' #scrollEvent
-- @
clearWidgetClassScrollEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassScrollEvent :: WidgetClass -> m ()
clearWidgetClassScrollEvent WidgetClass
s = IO () -> m ()
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_WidgetClassScrollEventFieldCallback)
-> FunPtr C_WidgetClassScrollEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassScrollEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
400) (FunPtr C_WidgetClassScrollEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassScrollEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassScrollEventFieldInfo
instance AttrInfo WidgetClassScrollEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassScrollEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassScrollEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassScrollEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassScrollEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassScrollEventFieldInfo = (~)Gtk.Callbacks.WidgetClassScrollEventFieldCallback
    type AttrTransferType WidgetClassScrollEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassScrollEventFieldCallback)
    type AttrGetType WidgetClassScrollEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassScrollEventFieldCallback
    type AttrLabel WidgetClassScrollEventFieldInfo = "scroll_event"
    type AttrOrigin WidgetClassScrollEventFieldInfo = WidgetClass
    attrGet = getWidgetClassScrollEvent
    attrSet = setWidgetClassScrollEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassScrollEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassScrollEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassScrollEventFieldCallback Nothing v)

widgetClass_scrollEvent :: AttrLabelProxy "scrollEvent"
widgetClass_scrollEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@motion_notify_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #motionNotifyEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassMotionNotifyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMotionNotifyEventFieldCallback -> m ()
setWidgetClassMotionNotifyEvent :: WidgetClass
-> FunPtr C_WidgetClassMotionNotifyEventFieldCallback -> m ()
setWidgetClassMotionNotifyEvent WidgetClass
s FunPtr C_WidgetClassMotionNotifyEventFieldCallback
val = IO () -> m ()
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_WidgetClassMotionNotifyEventFieldCallback)
-> FunPtr C_WidgetClassMotionNotifyEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMotionNotifyEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
408) (FunPtr C_WidgetClassMotionNotifyEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMotionNotifyEventFieldCallback)

-- | Set the value of the “@motion_notify_event@” 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' #motionNotifyEvent
-- @
clearWidgetClassMotionNotifyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMotionNotifyEvent :: WidgetClass -> m ()
clearWidgetClassMotionNotifyEvent WidgetClass
s = IO () -> m ()
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_WidgetClassMotionNotifyEventFieldCallback)
-> FunPtr C_WidgetClassMotionNotifyEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMotionNotifyEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
408) (FunPtr C_WidgetClassMotionNotifyEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMotionNotifyEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassMotionNotifyEventFieldInfo
instance AttrInfo WidgetClassMotionNotifyEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassMotionNotifyEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassMotionNotifyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassMotionNotifyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMotionNotifyEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassMotionNotifyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassMotionNotifyEventFieldCallback
    type AttrTransferType WidgetClassMotionNotifyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMotionNotifyEventFieldCallback)
    type AttrGetType WidgetClassMotionNotifyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassMotionNotifyEventFieldCallback
    type AttrLabel WidgetClassMotionNotifyEventFieldInfo = "motion_notify_event"
    type AttrOrigin WidgetClassMotionNotifyEventFieldInfo = WidgetClass
    attrGet = getWidgetClassMotionNotifyEvent
    attrSet = setWidgetClassMotionNotifyEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassMotionNotifyEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassMotionNotifyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassMotionNotifyEventFieldCallback Nothing v)

widgetClass_motionNotifyEvent :: AttrLabelProxy "motionNotifyEvent"
widgetClass_motionNotifyEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@delete_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #deleteEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDeleteEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDeleteEventFieldCallback -> m ()
setWidgetClassDeleteEvent :: WidgetClass -> FunPtr C_WidgetClassDeleteEventFieldCallback -> m ()
setWidgetClassDeleteEvent WidgetClass
s FunPtr C_WidgetClassDeleteEventFieldCallback
val = IO () -> m ()
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_WidgetClassDeleteEventFieldCallback)
-> FunPtr C_WidgetClassDeleteEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDeleteEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
416) (FunPtr C_WidgetClassDeleteEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDeleteEventFieldCallback)

-- | Set the value of the “@delete_event@” 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' #deleteEvent
-- @
clearWidgetClassDeleteEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDeleteEvent :: WidgetClass -> m ()
clearWidgetClassDeleteEvent WidgetClass
s = IO () -> m ()
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_WidgetClassDeleteEventFieldCallback)
-> FunPtr C_WidgetClassDeleteEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDeleteEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
416) (FunPtr C_WidgetClassDeleteEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDeleteEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDeleteEventFieldInfo
instance AttrInfo WidgetClassDeleteEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDeleteEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDeleteEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDeleteEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDeleteEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDeleteEventFieldInfo = (~)Gtk.Callbacks.WidgetClassDeleteEventFieldCallback
    type AttrTransferType WidgetClassDeleteEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDeleteEventFieldCallback)
    type AttrGetType WidgetClassDeleteEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassDeleteEventFieldCallback
    type AttrLabel WidgetClassDeleteEventFieldInfo = "delete_event"
    type AttrOrigin WidgetClassDeleteEventFieldInfo = WidgetClass
    attrGet = getWidgetClassDeleteEvent
    attrSet = setWidgetClassDeleteEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassDeleteEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDeleteEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassDeleteEventFieldCallback Nothing v)

widgetClass_deleteEvent :: AttrLabelProxy "deleteEvent"
widgetClass_deleteEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@destroy_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #destroyEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDestroyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDestroyEventFieldCallback -> m ()
setWidgetClassDestroyEvent :: WidgetClass -> FunPtr C_WidgetClassDeleteEventFieldCallback -> m ()
setWidgetClassDestroyEvent WidgetClass
s FunPtr C_WidgetClassDeleteEventFieldCallback
val = IO () -> m ()
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_WidgetClassDeleteEventFieldCallback)
-> FunPtr C_WidgetClassDeleteEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDeleteEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
424) (FunPtr C_WidgetClassDeleteEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDestroyEventFieldCallback)

-- | Set the value of the “@destroy_event@” 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' #destroyEvent
-- @
clearWidgetClassDestroyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDestroyEvent :: WidgetClass -> m ()
clearWidgetClassDestroyEvent WidgetClass
s = IO () -> m ()
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_WidgetClassDeleteEventFieldCallback)
-> FunPtr C_WidgetClassDeleteEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDeleteEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
424) (FunPtr C_WidgetClassDeleteEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDestroyEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDestroyEventFieldInfo
instance AttrInfo WidgetClassDestroyEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDestroyEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDestroyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDestroyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDestroyEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDestroyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassDestroyEventFieldCallback
    type AttrTransferType WidgetClassDestroyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDestroyEventFieldCallback)
    type AttrGetType WidgetClassDestroyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassDestroyEventFieldCallback
    type AttrLabel WidgetClassDestroyEventFieldInfo = "destroy_event"
    type AttrOrigin WidgetClassDestroyEventFieldInfo = WidgetClass
    attrGet = getWidgetClassDestroyEvent
    attrSet = setWidgetClassDestroyEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassDestroyEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDestroyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassDestroyEventFieldCallback Nothing v)

widgetClass_destroyEvent :: AttrLabelProxy "destroyEvent"
widgetClass_destroyEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@key_press_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #keyPressEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassKeyPressEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassKeyPressEventFieldCallback -> m ()
setWidgetClassKeyPressEvent :: WidgetClass
-> FunPtr C_WidgetClassKeyPressEventFieldCallback -> m ()
setWidgetClassKeyPressEvent WidgetClass
s FunPtr C_WidgetClassKeyPressEventFieldCallback
val = IO () -> m ()
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_WidgetClassKeyPressEventFieldCallback)
-> FunPtr C_WidgetClassKeyPressEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassKeyPressEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
432) (FunPtr C_WidgetClassKeyPressEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassKeyPressEventFieldCallback)

-- | Set the value of the “@key_press_event@” 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' #keyPressEvent
-- @
clearWidgetClassKeyPressEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassKeyPressEvent :: WidgetClass -> m ()
clearWidgetClassKeyPressEvent WidgetClass
s = IO () -> m ()
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_WidgetClassKeyPressEventFieldCallback)
-> FunPtr C_WidgetClassKeyPressEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassKeyPressEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
432) (FunPtr C_WidgetClassKeyPressEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassKeyPressEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassKeyPressEventFieldInfo
instance AttrInfo WidgetClassKeyPressEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassKeyPressEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassKeyPressEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassKeyPressEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassKeyPressEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassKeyPressEventFieldInfo = (~)Gtk.Callbacks.WidgetClassKeyPressEventFieldCallback
    type AttrTransferType WidgetClassKeyPressEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassKeyPressEventFieldCallback)
    type AttrGetType WidgetClassKeyPressEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassKeyPressEventFieldCallback
    type AttrLabel WidgetClassKeyPressEventFieldInfo = "key_press_event"
    type AttrOrigin WidgetClassKeyPressEventFieldInfo = WidgetClass
    attrGet = getWidgetClassKeyPressEvent
    attrSet = setWidgetClassKeyPressEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassKeyPressEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassKeyPressEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassKeyPressEventFieldCallback Nothing v)

widgetClass_keyPressEvent :: AttrLabelProxy "keyPressEvent"
widgetClass_keyPressEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@key_release_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #keyReleaseEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassKeyReleaseEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassKeyReleaseEventFieldCallback -> m ()
setWidgetClassKeyReleaseEvent :: WidgetClass
-> FunPtr C_WidgetClassKeyPressEventFieldCallback -> m ()
setWidgetClassKeyReleaseEvent WidgetClass
s FunPtr C_WidgetClassKeyPressEventFieldCallback
val = IO () -> m ()
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_WidgetClassKeyPressEventFieldCallback)
-> FunPtr C_WidgetClassKeyPressEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassKeyPressEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
440) (FunPtr C_WidgetClassKeyPressEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassKeyReleaseEventFieldCallback)

-- | Set the value of the “@key_release_event@” 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' #keyReleaseEvent
-- @
clearWidgetClassKeyReleaseEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassKeyReleaseEvent :: WidgetClass -> m ()
clearWidgetClassKeyReleaseEvent WidgetClass
s = IO () -> m ()
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_WidgetClassKeyPressEventFieldCallback)
-> FunPtr C_WidgetClassKeyPressEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassKeyPressEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
440) (FunPtr C_WidgetClassKeyPressEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassKeyReleaseEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassKeyReleaseEventFieldInfo
instance AttrInfo WidgetClassKeyReleaseEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassKeyReleaseEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassKeyReleaseEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassKeyReleaseEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassKeyReleaseEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassKeyReleaseEventFieldInfo = (~)Gtk.Callbacks.WidgetClassKeyReleaseEventFieldCallback
    type AttrTransferType WidgetClassKeyReleaseEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassKeyReleaseEventFieldCallback)
    type AttrGetType WidgetClassKeyReleaseEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassKeyReleaseEventFieldCallback
    type AttrLabel WidgetClassKeyReleaseEventFieldInfo = "key_release_event"
    type AttrOrigin WidgetClassKeyReleaseEventFieldInfo = WidgetClass
    attrGet = getWidgetClassKeyReleaseEvent
    attrSet = setWidgetClassKeyReleaseEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassKeyReleaseEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassKeyReleaseEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassKeyReleaseEventFieldCallback Nothing v)

widgetClass_keyReleaseEvent :: AttrLabelProxy "keyReleaseEvent"
widgetClass_keyReleaseEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@enter_notify_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #enterNotifyEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassEnterNotifyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassEnterNotifyEventFieldCallback -> m ()
setWidgetClassEnterNotifyEvent :: WidgetClass
-> FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> m ()
setWidgetClassEnterNotifyEvent WidgetClass
s FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val = IO () -> m ()
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_WidgetClassEnterNotifyEventFieldCallback)
-> FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassEnterNotifyEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
448) (FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassEnterNotifyEventFieldCallback)

-- | Set the value of the “@enter_notify_event@” 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' #enterNotifyEvent
-- @
clearWidgetClassEnterNotifyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassEnterNotifyEvent :: WidgetClass -> m ()
clearWidgetClassEnterNotifyEvent WidgetClass
s = IO () -> m ()
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_WidgetClassEnterNotifyEventFieldCallback)
-> FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassEnterNotifyEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
448) (FunPtr C_WidgetClassEnterNotifyEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassEnterNotifyEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassEnterNotifyEventFieldInfo
instance AttrInfo WidgetClassEnterNotifyEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassEnterNotifyEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassEnterNotifyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassEnterNotifyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassEnterNotifyEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassEnterNotifyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassEnterNotifyEventFieldCallback
    type AttrTransferType WidgetClassEnterNotifyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassEnterNotifyEventFieldCallback)
    type AttrGetType WidgetClassEnterNotifyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassEnterNotifyEventFieldCallback
    type AttrLabel WidgetClassEnterNotifyEventFieldInfo = "enter_notify_event"
    type AttrOrigin WidgetClassEnterNotifyEventFieldInfo = WidgetClass
    attrGet = getWidgetClassEnterNotifyEvent
    attrSet = setWidgetClassEnterNotifyEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassEnterNotifyEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassEnterNotifyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassEnterNotifyEventFieldCallback Nothing v)

widgetClass_enterNotifyEvent :: AttrLabelProxy "enterNotifyEvent"
widgetClass_enterNotifyEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@leave_notify_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #leaveNotifyEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassLeaveNotifyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassLeaveNotifyEventFieldCallback -> m ()
setWidgetClassLeaveNotifyEvent :: WidgetClass
-> FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> m ()
setWidgetClassLeaveNotifyEvent WidgetClass
s FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val = IO () -> m ()
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_WidgetClassEnterNotifyEventFieldCallback)
-> FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassEnterNotifyEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
456) (FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassLeaveNotifyEventFieldCallback)

-- | Set the value of the “@leave_notify_event@” 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' #leaveNotifyEvent
-- @
clearWidgetClassLeaveNotifyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassLeaveNotifyEvent :: WidgetClass -> m ()
clearWidgetClassLeaveNotifyEvent WidgetClass
s = IO () -> m ()
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_WidgetClassEnterNotifyEventFieldCallback)
-> FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassEnterNotifyEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
456) (FunPtr C_WidgetClassEnterNotifyEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassLeaveNotifyEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassLeaveNotifyEventFieldInfo
instance AttrInfo WidgetClassLeaveNotifyEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassLeaveNotifyEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassLeaveNotifyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassLeaveNotifyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassLeaveNotifyEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassLeaveNotifyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassLeaveNotifyEventFieldCallback
    type AttrTransferType WidgetClassLeaveNotifyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassLeaveNotifyEventFieldCallback)
    type AttrGetType WidgetClassLeaveNotifyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassLeaveNotifyEventFieldCallback
    type AttrLabel WidgetClassLeaveNotifyEventFieldInfo = "leave_notify_event"
    type AttrOrigin WidgetClassLeaveNotifyEventFieldInfo = WidgetClass
    attrGet = getWidgetClassLeaveNotifyEvent
    attrSet = setWidgetClassLeaveNotifyEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassLeaveNotifyEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassLeaveNotifyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassLeaveNotifyEventFieldCallback Nothing v)

widgetClass_leaveNotifyEvent :: AttrLabelProxy "leaveNotifyEvent"
widgetClass_leaveNotifyEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@configure_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #configureEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassConfigureEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassConfigureEventFieldCallback -> m ()
setWidgetClassConfigureEvent :: WidgetClass
-> FunPtr C_WidgetClassConfigureEventFieldCallback -> m ()
setWidgetClassConfigureEvent WidgetClass
s FunPtr C_WidgetClassConfigureEventFieldCallback
val = IO () -> m ()
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_WidgetClassConfigureEventFieldCallback)
-> FunPtr C_WidgetClassConfigureEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassConfigureEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
464) (FunPtr C_WidgetClassConfigureEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassConfigureEventFieldCallback)

-- | Set the value of the “@configure_event@” 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' #configureEvent
-- @
clearWidgetClassConfigureEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassConfigureEvent :: WidgetClass -> m ()
clearWidgetClassConfigureEvent WidgetClass
s = IO () -> m ()
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_WidgetClassConfigureEventFieldCallback)
-> FunPtr C_WidgetClassConfigureEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassConfigureEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
464) (FunPtr C_WidgetClassConfigureEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassConfigureEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassConfigureEventFieldInfo
instance AttrInfo WidgetClassConfigureEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassConfigureEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassConfigureEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassConfigureEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassConfigureEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassConfigureEventFieldInfo = (~)Gtk.Callbacks.WidgetClassConfigureEventFieldCallback
    type AttrTransferType WidgetClassConfigureEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassConfigureEventFieldCallback)
    type AttrGetType WidgetClassConfigureEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassConfigureEventFieldCallback
    type AttrLabel WidgetClassConfigureEventFieldInfo = "configure_event"
    type AttrOrigin WidgetClassConfigureEventFieldInfo = WidgetClass
    attrGet = getWidgetClassConfigureEvent
    attrSet = setWidgetClassConfigureEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassConfigureEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassConfigureEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassConfigureEventFieldCallback Nothing v)

widgetClass_configureEvent :: AttrLabelProxy "configureEvent"
widgetClass_configureEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@focus_in_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #focusInEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassFocusInEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassFocusInEventFieldCallback -> m ()
setWidgetClassFocusInEvent :: WidgetClass
-> FunPtr C_WidgetClassFocusInEventFieldCallback -> m ()
setWidgetClassFocusInEvent WidgetClass
s FunPtr C_WidgetClassFocusInEventFieldCallback
val = IO () -> m ()
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_WidgetClassFocusInEventFieldCallback)
-> FunPtr C_WidgetClassFocusInEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusInEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
472) (FunPtr C_WidgetClassFocusInEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassFocusInEventFieldCallback)

-- | Set the value of the “@focus_in_event@” 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' #focusInEvent
-- @
clearWidgetClassFocusInEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassFocusInEvent :: WidgetClass -> m ()
clearWidgetClassFocusInEvent WidgetClass
s = IO () -> m ()
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_WidgetClassFocusInEventFieldCallback)
-> FunPtr C_WidgetClassFocusInEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusInEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
472) (FunPtr C_WidgetClassFocusInEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassFocusInEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassFocusInEventFieldInfo
instance AttrInfo WidgetClassFocusInEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassFocusInEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassFocusInEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassFocusInEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassFocusInEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassFocusInEventFieldInfo = (~)Gtk.Callbacks.WidgetClassFocusInEventFieldCallback
    type AttrTransferType WidgetClassFocusInEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassFocusInEventFieldCallback)
    type AttrGetType WidgetClassFocusInEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassFocusInEventFieldCallback
    type AttrLabel WidgetClassFocusInEventFieldInfo = "focus_in_event"
    type AttrOrigin WidgetClassFocusInEventFieldInfo = WidgetClass
    attrGet = getWidgetClassFocusInEvent
    attrSet = setWidgetClassFocusInEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassFocusInEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassFocusInEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassFocusInEventFieldCallback Nothing v)

widgetClass_focusInEvent :: AttrLabelProxy "focusInEvent"
widgetClass_focusInEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@focus_out_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #focusOutEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassFocusOutEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassFocusOutEventFieldCallback -> m ()
setWidgetClassFocusOutEvent :: WidgetClass
-> FunPtr C_WidgetClassFocusInEventFieldCallback -> m ()
setWidgetClassFocusOutEvent WidgetClass
s FunPtr C_WidgetClassFocusInEventFieldCallback
val = IO () -> m ()
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_WidgetClassFocusInEventFieldCallback)
-> FunPtr C_WidgetClassFocusInEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusInEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
480) (FunPtr C_WidgetClassFocusInEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassFocusOutEventFieldCallback)

-- | Set the value of the “@focus_out_event@” 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' #focusOutEvent
-- @
clearWidgetClassFocusOutEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassFocusOutEvent :: WidgetClass -> m ()
clearWidgetClassFocusOutEvent WidgetClass
s = IO () -> m ()
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_WidgetClassFocusInEventFieldCallback)
-> FunPtr C_WidgetClassFocusInEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusInEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
480) (FunPtr C_WidgetClassFocusInEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassFocusOutEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassFocusOutEventFieldInfo
instance AttrInfo WidgetClassFocusOutEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassFocusOutEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassFocusOutEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassFocusOutEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassFocusOutEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassFocusOutEventFieldInfo = (~)Gtk.Callbacks.WidgetClassFocusOutEventFieldCallback
    type AttrTransferType WidgetClassFocusOutEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassFocusOutEventFieldCallback)
    type AttrGetType WidgetClassFocusOutEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassFocusOutEventFieldCallback
    type AttrLabel WidgetClassFocusOutEventFieldInfo = "focus_out_event"
    type AttrOrigin WidgetClassFocusOutEventFieldInfo = WidgetClass
    attrGet = getWidgetClassFocusOutEvent
    attrSet = setWidgetClassFocusOutEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassFocusOutEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassFocusOutEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassFocusOutEventFieldCallback Nothing v)

widgetClass_focusOutEvent :: AttrLabelProxy "focusOutEvent"
widgetClass_focusOutEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@map_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #mapEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassMapEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMapEventFieldCallback -> m ()
setWidgetClassMapEvent :: WidgetClass -> FunPtr C_WidgetClassDeleteEventFieldCallback -> m ()
setWidgetClassMapEvent WidgetClass
s FunPtr C_WidgetClassDeleteEventFieldCallback
val = IO () -> m ()
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_WidgetClassDeleteEventFieldCallback)
-> FunPtr C_WidgetClassDeleteEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDeleteEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
488) (FunPtr C_WidgetClassDeleteEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMapEventFieldCallback)

-- | Set the value of the “@map_event@” 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' #mapEvent
-- @
clearWidgetClassMapEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMapEvent :: WidgetClass -> m ()
clearWidgetClassMapEvent WidgetClass
s = IO () -> m ()
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_WidgetClassDeleteEventFieldCallback)
-> FunPtr C_WidgetClassDeleteEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDeleteEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
488) (FunPtr C_WidgetClassDeleteEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMapEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassMapEventFieldInfo
instance AttrInfo WidgetClassMapEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassMapEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassMapEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassMapEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMapEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassMapEventFieldInfo = (~)Gtk.Callbacks.WidgetClassMapEventFieldCallback
    type AttrTransferType WidgetClassMapEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMapEventFieldCallback)
    type AttrGetType WidgetClassMapEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassMapEventFieldCallback
    type AttrLabel WidgetClassMapEventFieldInfo = "map_event"
    type AttrOrigin WidgetClassMapEventFieldInfo = WidgetClass
    attrGet = getWidgetClassMapEvent
    attrSet = setWidgetClassMapEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassMapEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassMapEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassMapEventFieldCallback Nothing v)

widgetClass_mapEvent :: AttrLabelProxy "mapEvent"
widgetClass_mapEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@unmap_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #unmapEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassUnmapEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnmapEventFieldCallback -> m ()
setWidgetClassUnmapEvent :: WidgetClass -> FunPtr C_WidgetClassDeleteEventFieldCallback -> m ()
setWidgetClassUnmapEvent WidgetClass
s FunPtr C_WidgetClassDeleteEventFieldCallback
val = IO () -> m ()
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_WidgetClassDeleteEventFieldCallback)
-> FunPtr C_WidgetClassDeleteEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDeleteEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
496) (FunPtr C_WidgetClassDeleteEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassUnmapEventFieldCallback)

-- | Set the value of the “@unmap_event@” 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' #unmapEvent
-- @
clearWidgetClassUnmapEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassUnmapEvent :: WidgetClass -> m ()
clearWidgetClassUnmapEvent WidgetClass
s = IO () -> m ()
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_WidgetClassDeleteEventFieldCallback)
-> FunPtr C_WidgetClassDeleteEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDeleteEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
496) (FunPtr C_WidgetClassDeleteEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassUnmapEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassUnmapEventFieldInfo
instance AttrInfo WidgetClassUnmapEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassUnmapEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassUnmapEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassUnmapEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassUnmapEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassUnmapEventFieldInfo = (~)Gtk.Callbacks.WidgetClassUnmapEventFieldCallback
    type AttrTransferType WidgetClassUnmapEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassUnmapEventFieldCallback)
    type AttrGetType WidgetClassUnmapEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassUnmapEventFieldCallback
    type AttrLabel WidgetClassUnmapEventFieldInfo = "unmap_event"
    type AttrOrigin WidgetClassUnmapEventFieldInfo = WidgetClass
    attrGet = getWidgetClassUnmapEvent
    attrSet = setWidgetClassUnmapEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassUnmapEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassUnmapEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassUnmapEventFieldCallback Nothing v)

widgetClass_unmapEvent :: AttrLabelProxy "unmapEvent"
widgetClass_unmapEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@property_notify_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #propertyNotifyEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassPropertyNotifyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassPropertyNotifyEventFieldCallback -> m ()
setWidgetClassPropertyNotifyEvent :: WidgetClass
-> FunPtr C_WidgetClassPropertyNotifyEventFieldCallback -> m ()
setWidgetClassPropertyNotifyEvent WidgetClass
s FunPtr C_WidgetClassPropertyNotifyEventFieldCallback
val = IO () -> m ()
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_WidgetClassPropertyNotifyEventFieldCallback)
-> FunPtr C_WidgetClassPropertyNotifyEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
504) (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassPropertyNotifyEventFieldCallback)

-- | Set the value of the “@property_notify_event@” 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' #propertyNotifyEvent
-- @
clearWidgetClassPropertyNotifyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassPropertyNotifyEvent :: WidgetClass -> m ()
clearWidgetClassPropertyNotifyEvent WidgetClass
s = IO () -> m ()
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_WidgetClassPropertyNotifyEventFieldCallback)
-> FunPtr C_WidgetClassPropertyNotifyEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
504) (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassPropertyNotifyEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassPropertyNotifyEventFieldInfo
instance AttrInfo WidgetClassPropertyNotifyEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassPropertyNotifyEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassPropertyNotifyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassPropertyNotifyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassPropertyNotifyEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassPropertyNotifyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassPropertyNotifyEventFieldCallback
    type AttrTransferType WidgetClassPropertyNotifyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassPropertyNotifyEventFieldCallback)
    type AttrGetType WidgetClassPropertyNotifyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassPropertyNotifyEventFieldCallback
    type AttrLabel WidgetClassPropertyNotifyEventFieldInfo = "property_notify_event"
    type AttrOrigin WidgetClassPropertyNotifyEventFieldInfo = WidgetClass
    attrGet = getWidgetClassPropertyNotifyEvent
    attrSet = setWidgetClassPropertyNotifyEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassPropertyNotifyEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassPropertyNotifyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassPropertyNotifyEventFieldCallback Nothing v)

widgetClass_propertyNotifyEvent :: AttrLabelProxy "propertyNotifyEvent"
widgetClass_propertyNotifyEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@selection_clear_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #selectionClearEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSelectionClearEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSelectionClearEventFieldCallback -> m ()
setWidgetClassSelectionClearEvent :: WidgetClass
-> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> m ()
setWidgetClassSelectionClearEvent WidgetClass
s FunPtr C_WidgetClassSelectionClearEventFieldCallback
val = IO () -> m ()
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_WidgetClassSelectionClearEventFieldCallback)
-> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassSelectionClearEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
512) (FunPtr C_WidgetClassSelectionClearEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionClearEventFieldCallback)

-- | Set the value of the “@selection_clear_event@” 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' #selectionClearEvent
-- @
clearWidgetClassSelectionClearEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionClearEvent :: WidgetClass -> m ()
clearWidgetClassSelectionClearEvent WidgetClass
s = IO () -> m ()
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_WidgetClassSelectionClearEventFieldCallback)
-> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassSelectionClearEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
512) (FunPtr C_WidgetClassSelectionClearEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionClearEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSelectionClearEventFieldInfo
instance AttrInfo WidgetClassSelectionClearEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSelectionClearEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSelectionClearEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSelectionClearEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSelectionClearEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSelectionClearEventFieldInfo = (~)Gtk.Callbacks.WidgetClassSelectionClearEventFieldCallback
    type AttrTransferType WidgetClassSelectionClearEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSelectionClearEventFieldCallback)
    type AttrGetType WidgetClassSelectionClearEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassSelectionClearEventFieldCallback
    type AttrLabel WidgetClassSelectionClearEventFieldInfo = "selection_clear_event"
    type AttrOrigin WidgetClassSelectionClearEventFieldInfo = WidgetClass
    attrGet = getWidgetClassSelectionClearEvent
    attrSet = setWidgetClassSelectionClearEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassSelectionClearEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSelectionClearEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassSelectionClearEventFieldCallback Nothing v)

widgetClass_selectionClearEvent :: AttrLabelProxy "selectionClearEvent"
widgetClass_selectionClearEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@selection_request_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #selectionRequestEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSelectionRequestEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSelectionRequestEventFieldCallback -> m ()
setWidgetClassSelectionRequestEvent :: WidgetClass
-> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> m ()
setWidgetClassSelectionRequestEvent WidgetClass
s FunPtr C_WidgetClassSelectionClearEventFieldCallback
val = IO () -> m ()
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_WidgetClassSelectionClearEventFieldCallback)
-> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassSelectionClearEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
520) (FunPtr C_WidgetClassSelectionClearEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionRequestEventFieldCallback)

-- | Set the value of the “@selection_request_event@” 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' #selectionRequestEvent
-- @
clearWidgetClassSelectionRequestEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionRequestEvent :: WidgetClass -> m ()
clearWidgetClassSelectionRequestEvent WidgetClass
s = IO () -> m ()
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_WidgetClassSelectionClearEventFieldCallback)
-> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassSelectionClearEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
520) (FunPtr C_WidgetClassSelectionClearEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionRequestEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSelectionRequestEventFieldInfo
instance AttrInfo WidgetClassSelectionRequestEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSelectionRequestEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSelectionRequestEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSelectionRequestEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSelectionRequestEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSelectionRequestEventFieldInfo = (~)Gtk.Callbacks.WidgetClassSelectionRequestEventFieldCallback
    type AttrTransferType WidgetClassSelectionRequestEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSelectionRequestEventFieldCallback)
    type AttrGetType WidgetClassSelectionRequestEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassSelectionRequestEventFieldCallback
    type AttrLabel WidgetClassSelectionRequestEventFieldInfo = "selection_request_event"
    type AttrOrigin WidgetClassSelectionRequestEventFieldInfo = WidgetClass
    attrGet = getWidgetClassSelectionRequestEvent
    attrSet = setWidgetClassSelectionRequestEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassSelectionRequestEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSelectionRequestEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassSelectionRequestEventFieldCallback Nothing v)

widgetClass_selectionRequestEvent :: AttrLabelProxy "selectionRequestEvent"
widgetClass_selectionRequestEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@selection_notify_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #selectionNotifyEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSelectionNotifyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSelectionNotifyEventFieldCallback -> m ()
setWidgetClassSelectionNotifyEvent :: WidgetClass
-> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> m ()
setWidgetClassSelectionNotifyEvent WidgetClass
s FunPtr C_WidgetClassSelectionClearEventFieldCallback
val = IO () -> m ()
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_WidgetClassSelectionClearEventFieldCallback)
-> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassSelectionClearEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
528) (FunPtr C_WidgetClassSelectionClearEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionNotifyEventFieldCallback)

-- | Set the value of the “@selection_notify_event@” 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' #selectionNotifyEvent
-- @
clearWidgetClassSelectionNotifyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionNotifyEvent :: WidgetClass -> m ()
clearWidgetClassSelectionNotifyEvent WidgetClass
s = IO () -> m ()
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_WidgetClassSelectionClearEventFieldCallback)
-> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassSelectionClearEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
528) (FunPtr C_WidgetClassSelectionClearEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionNotifyEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSelectionNotifyEventFieldInfo
instance AttrInfo WidgetClassSelectionNotifyEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSelectionNotifyEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSelectionNotifyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSelectionNotifyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSelectionNotifyEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSelectionNotifyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassSelectionNotifyEventFieldCallback
    type AttrTransferType WidgetClassSelectionNotifyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSelectionNotifyEventFieldCallback)
    type AttrGetType WidgetClassSelectionNotifyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassSelectionNotifyEventFieldCallback
    type AttrLabel WidgetClassSelectionNotifyEventFieldInfo = "selection_notify_event"
    type AttrOrigin WidgetClassSelectionNotifyEventFieldInfo = WidgetClass
    attrGet = getWidgetClassSelectionNotifyEvent
    attrSet = setWidgetClassSelectionNotifyEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassSelectionNotifyEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSelectionNotifyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassSelectionNotifyEventFieldCallback Nothing v)

widgetClass_selectionNotifyEvent :: AttrLabelProxy "selectionNotifyEvent"
widgetClass_selectionNotifyEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@proximity_in_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #proximityInEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassProximityInEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassProximityInEventFieldCallback -> m ()
setWidgetClassProximityInEvent :: WidgetClass
-> FunPtr C_WidgetClassProximityInEventFieldCallback -> m ()
setWidgetClassProximityInEvent WidgetClass
s FunPtr C_WidgetClassProximityInEventFieldCallback
val = IO () -> m ()
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_WidgetClassProximityInEventFieldCallback)
-> FunPtr C_WidgetClassProximityInEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassProximityInEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
536) (FunPtr C_WidgetClassProximityInEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassProximityInEventFieldCallback)

-- | Set the value of the “@proximity_in_event@” 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' #proximityInEvent
-- @
clearWidgetClassProximityInEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassProximityInEvent :: WidgetClass -> m ()
clearWidgetClassProximityInEvent WidgetClass
s = IO () -> m ()
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_WidgetClassProximityInEventFieldCallback)
-> FunPtr C_WidgetClassProximityInEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassProximityInEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
536) (FunPtr C_WidgetClassProximityInEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassProximityInEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassProximityInEventFieldInfo
instance AttrInfo WidgetClassProximityInEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassProximityInEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassProximityInEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassProximityInEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassProximityInEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassProximityInEventFieldInfo = (~)Gtk.Callbacks.WidgetClassProximityInEventFieldCallback
    type AttrTransferType WidgetClassProximityInEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassProximityInEventFieldCallback)
    type AttrGetType WidgetClassProximityInEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassProximityInEventFieldCallback
    type AttrLabel WidgetClassProximityInEventFieldInfo = "proximity_in_event"
    type AttrOrigin WidgetClassProximityInEventFieldInfo = WidgetClass
    attrGet = getWidgetClassProximityInEvent
    attrSet = setWidgetClassProximityInEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassProximityInEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassProximityInEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassProximityInEventFieldCallback Nothing v)

widgetClass_proximityInEvent :: AttrLabelProxy "proximityInEvent"
widgetClass_proximityInEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@proximity_out_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #proximityOutEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassProximityOutEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassProximityOutEventFieldCallback -> m ()
setWidgetClassProximityOutEvent :: WidgetClass
-> FunPtr C_WidgetClassProximityInEventFieldCallback -> m ()
setWidgetClassProximityOutEvent WidgetClass
s FunPtr C_WidgetClassProximityInEventFieldCallback
val = IO () -> m ()
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_WidgetClassProximityInEventFieldCallback)
-> FunPtr C_WidgetClassProximityInEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassProximityInEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
544) (FunPtr C_WidgetClassProximityInEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassProximityOutEventFieldCallback)

-- | Set the value of the “@proximity_out_event@” 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' #proximityOutEvent
-- @
clearWidgetClassProximityOutEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassProximityOutEvent :: WidgetClass -> m ()
clearWidgetClassProximityOutEvent WidgetClass
s = IO () -> m ()
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_WidgetClassProximityInEventFieldCallback)
-> FunPtr C_WidgetClassProximityInEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassProximityInEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
544) (FunPtr C_WidgetClassProximityInEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassProximityOutEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassProximityOutEventFieldInfo
instance AttrInfo WidgetClassProximityOutEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassProximityOutEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassProximityOutEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassProximityOutEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassProximityOutEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassProximityOutEventFieldInfo = (~)Gtk.Callbacks.WidgetClassProximityOutEventFieldCallback
    type AttrTransferType WidgetClassProximityOutEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassProximityOutEventFieldCallback)
    type AttrGetType WidgetClassProximityOutEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassProximityOutEventFieldCallback
    type AttrLabel WidgetClassProximityOutEventFieldInfo = "proximity_out_event"
    type AttrOrigin WidgetClassProximityOutEventFieldInfo = WidgetClass
    attrGet = getWidgetClassProximityOutEvent
    attrSet = setWidgetClassProximityOutEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassProximityOutEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassProximityOutEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassProximityOutEventFieldCallback Nothing v)

widgetClass_proximityOutEvent :: AttrLabelProxy "proximityOutEvent"
widgetClass_proximityOutEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@visibility_notify_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #visibilityNotifyEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassVisibilityNotifyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassVisibilityNotifyEventFieldCallback -> m ()
setWidgetClassVisibilityNotifyEvent :: WidgetClass
-> FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback -> m ()
setWidgetClassVisibilityNotifyEvent WidgetClass
s FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback
val = IO () -> m ()
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_WidgetClassVisibilityNotifyEventFieldCallback)
-> FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
552) (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassVisibilityNotifyEventFieldCallback)

-- | Set the value of the “@visibility_notify_event@” 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' #visibilityNotifyEvent
-- @
clearWidgetClassVisibilityNotifyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassVisibilityNotifyEvent :: WidgetClass -> m ()
clearWidgetClassVisibilityNotifyEvent WidgetClass
s = IO () -> m ()
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_WidgetClassVisibilityNotifyEventFieldCallback)
-> FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
552) (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassVisibilityNotifyEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassVisibilityNotifyEventFieldInfo
instance AttrInfo WidgetClassVisibilityNotifyEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassVisibilityNotifyEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassVisibilityNotifyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassVisibilityNotifyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassVisibilityNotifyEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassVisibilityNotifyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassVisibilityNotifyEventFieldCallback
    type AttrTransferType WidgetClassVisibilityNotifyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassVisibilityNotifyEventFieldCallback)
    type AttrGetType WidgetClassVisibilityNotifyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassVisibilityNotifyEventFieldCallback
    type AttrLabel WidgetClassVisibilityNotifyEventFieldInfo = "visibility_notify_event"
    type AttrOrigin WidgetClassVisibilityNotifyEventFieldInfo = WidgetClass
    attrGet = getWidgetClassVisibilityNotifyEvent
    attrSet = setWidgetClassVisibilityNotifyEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassVisibilityNotifyEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassVisibilityNotifyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassVisibilityNotifyEventFieldCallback Nothing v)

widgetClass_visibilityNotifyEvent :: AttrLabelProxy "visibilityNotifyEvent"
widgetClass_visibilityNotifyEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@window_state_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #windowStateEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassWindowStateEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassWindowStateEventFieldCallback -> m ()
setWidgetClassWindowStateEvent :: WidgetClass
-> FunPtr C_WidgetClassWindowStateEventFieldCallback -> m ()
setWidgetClassWindowStateEvent WidgetClass
s FunPtr C_WidgetClassWindowStateEventFieldCallback
val = IO () -> m ()
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_WidgetClassWindowStateEventFieldCallback)
-> FunPtr C_WidgetClassWindowStateEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassWindowStateEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
560) (FunPtr C_WidgetClassWindowStateEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassWindowStateEventFieldCallback)

-- | Set the value of the “@window_state_event@” 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' #windowStateEvent
-- @
clearWidgetClassWindowStateEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassWindowStateEvent :: WidgetClass -> m ()
clearWidgetClassWindowStateEvent WidgetClass
s = IO () -> m ()
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_WidgetClassWindowStateEventFieldCallback)
-> FunPtr C_WidgetClassWindowStateEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassWindowStateEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
560) (FunPtr C_WidgetClassWindowStateEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassWindowStateEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassWindowStateEventFieldInfo
instance AttrInfo WidgetClassWindowStateEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassWindowStateEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassWindowStateEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassWindowStateEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassWindowStateEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassWindowStateEventFieldInfo = (~)Gtk.Callbacks.WidgetClassWindowStateEventFieldCallback
    type AttrTransferType WidgetClassWindowStateEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassWindowStateEventFieldCallback)
    type AttrGetType WidgetClassWindowStateEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassWindowStateEventFieldCallback
    type AttrLabel WidgetClassWindowStateEventFieldInfo = "window_state_event"
    type AttrOrigin WidgetClassWindowStateEventFieldInfo = WidgetClass
    attrGet = getWidgetClassWindowStateEvent
    attrSet = setWidgetClassWindowStateEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassWindowStateEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassWindowStateEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassWindowStateEventFieldCallback Nothing v)

widgetClass_windowStateEvent :: AttrLabelProxy "windowStateEvent"
widgetClass_windowStateEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@damage_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #damageEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDamageEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDamageEventFieldCallback -> m ()
setWidgetClassDamageEvent :: WidgetClass -> FunPtr C_WidgetClassDamageEventFieldCallback -> m ()
setWidgetClassDamageEvent WidgetClass
s FunPtr C_WidgetClassDamageEventFieldCallback
val = IO () -> m ()
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_WidgetClassDamageEventFieldCallback)
-> FunPtr C_WidgetClassDamageEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDamageEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
568) (FunPtr C_WidgetClassDamageEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDamageEventFieldCallback)

-- | Set the value of the “@damage_event@” 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' #damageEvent
-- @
clearWidgetClassDamageEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDamageEvent :: WidgetClass -> m ()
clearWidgetClassDamageEvent WidgetClass
s = IO () -> m ()
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_WidgetClassDamageEventFieldCallback)
-> FunPtr C_WidgetClassDamageEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDamageEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
568) (FunPtr C_WidgetClassDamageEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDamageEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDamageEventFieldInfo
instance AttrInfo WidgetClassDamageEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDamageEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDamageEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDamageEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDamageEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDamageEventFieldInfo = (~)Gtk.Callbacks.WidgetClassDamageEventFieldCallback
    type AttrTransferType WidgetClassDamageEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDamageEventFieldCallback)
    type AttrGetType WidgetClassDamageEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassDamageEventFieldCallback
    type AttrLabel WidgetClassDamageEventFieldInfo = "damage_event"
    type AttrOrigin WidgetClassDamageEventFieldInfo = WidgetClass
    attrGet = getWidgetClassDamageEvent
    attrSet = setWidgetClassDamageEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassDamageEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDamageEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassDamageEventFieldCallback Nothing v)

widgetClass_damageEvent :: AttrLabelProxy "damageEvent"
widgetClass_damageEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@grab_broken_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #grabBrokenEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGrabBrokenEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGrabBrokenEventFieldCallback -> m ()
setWidgetClassGrabBrokenEvent :: WidgetClass
-> FunPtr C_WidgetClassGrabBrokenEventFieldCallback -> m ()
setWidgetClassGrabBrokenEvent WidgetClass
s FunPtr C_WidgetClassGrabBrokenEventFieldCallback
val = IO () -> m ()
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_WidgetClassGrabBrokenEventFieldCallback)
-> FunPtr C_WidgetClassGrabBrokenEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabBrokenEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
576) (FunPtr C_WidgetClassGrabBrokenEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGrabBrokenEventFieldCallback)

-- | Set the value of the “@grab_broken_event@” 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' #grabBrokenEvent
-- @
clearWidgetClassGrabBrokenEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabBrokenEvent :: WidgetClass -> m ()
clearWidgetClassGrabBrokenEvent WidgetClass
s = IO () -> m ()
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_WidgetClassGrabBrokenEventFieldCallback)
-> FunPtr C_WidgetClassGrabBrokenEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabBrokenEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
576) (FunPtr C_WidgetClassGrabBrokenEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGrabBrokenEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGrabBrokenEventFieldInfo
instance AttrInfo WidgetClassGrabBrokenEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGrabBrokenEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGrabBrokenEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGrabBrokenEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGrabBrokenEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGrabBrokenEventFieldInfo = (~)Gtk.Callbacks.WidgetClassGrabBrokenEventFieldCallback
    type AttrTransferType WidgetClassGrabBrokenEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGrabBrokenEventFieldCallback)
    type AttrGetType WidgetClassGrabBrokenEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassGrabBrokenEventFieldCallback
    type AttrLabel WidgetClassGrabBrokenEventFieldInfo = "grab_broken_event"
    type AttrOrigin WidgetClassGrabBrokenEventFieldInfo = WidgetClass
    attrGet = getWidgetClassGrabBrokenEvent
    attrSet = setWidgetClassGrabBrokenEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassGrabBrokenEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGrabBrokenEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassGrabBrokenEventFieldCallback Nothing v)

widgetClass_grabBrokenEvent :: AttrLabelProxy "grabBrokenEvent"
widgetClass_grabBrokenEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@selection_get@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #selectionGet 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSelectionGet :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSelectionGetFieldCallback -> m ()
setWidgetClassSelectionGet :: WidgetClass
-> FunPtr C_WidgetClassSelectionGetFieldCallback -> m ()
setWidgetClassSelectionGet WidgetClass
s FunPtr C_WidgetClassSelectionGetFieldCallback
val = IO () -> m ()
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_WidgetClassSelectionGetFieldCallback)
-> FunPtr C_WidgetClassSelectionGetFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSelectionGetFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
584) (FunPtr C_WidgetClassSelectionGetFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionGetFieldCallback)

-- | Set the value of the “@selection_get@” 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' #selectionGet
-- @
clearWidgetClassSelectionGet :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionGet :: WidgetClass -> m ()
clearWidgetClassSelectionGet WidgetClass
s = IO () -> m ()
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_WidgetClassSelectionGetFieldCallback)
-> FunPtr C_WidgetClassSelectionGetFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSelectionGetFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
584) (FunPtr C_WidgetClassSelectionGetFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionGetFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSelectionGetFieldInfo
instance AttrInfo WidgetClassSelectionGetFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSelectionGetFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSelectionGetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSelectionGetFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSelectionGetFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSelectionGetFieldInfo = (~)Gtk.Callbacks.WidgetClassSelectionGetFieldCallback
    type AttrTransferType WidgetClassSelectionGetFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSelectionGetFieldCallback)
    type AttrGetType WidgetClassSelectionGetFieldInfo = Maybe Gtk.Callbacks.WidgetClassSelectionGetFieldCallback
    type AttrLabel WidgetClassSelectionGetFieldInfo = "selection_get"
    type AttrOrigin WidgetClassSelectionGetFieldInfo = WidgetClass
    attrGet = getWidgetClassSelectionGet
    attrSet = setWidgetClassSelectionGet
    attrConstruct = undefined
    attrClear = clearWidgetClassSelectionGet
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSelectionGetFieldCallback (Gtk.Callbacks.wrap_WidgetClassSelectionGetFieldCallback Nothing v)

widgetClass_selectionGet :: AttrLabelProxy "selectionGet"
widgetClass_selectionGet = AttrLabelProxy

#endif


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

-- | Set the value of the “@selection_received@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #selectionReceived 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSelectionReceived :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSelectionReceivedFieldCallback -> m ()
setWidgetClassSelectionReceived :: WidgetClass
-> FunPtr C_WidgetClassSelectionReceivedFieldCallback -> m ()
setWidgetClassSelectionReceived WidgetClass
s FunPtr C_WidgetClassSelectionReceivedFieldCallback
val = IO () -> m ()
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_WidgetClassSelectionReceivedFieldCallback)
-> FunPtr C_WidgetClassSelectionReceivedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSelectionReceivedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
592) (FunPtr C_WidgetClassSelectionReceivedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionReceivedFieldCallback)

-- | Set the value of the “@selection_received@” 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' #selectionReceived
-- @
clearWidgetClassSelectionReceived :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionReceived :: WidgetClass -> m ()
clearWidgetClassSelectionReceived WidgetClass
s = IO () -> m ()
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_WidgetClassSelectionReceivedFieldCallback)
-> FunPtr C_WidgetClassSelectionReceivedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSelectionReceivedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
592) (FunPtr C_WidgetClassSelectionReceivedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionReceivedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSelectionReceivedFieldInfo
instance AttrInfo WidgetClassSelectionReceivedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSelectionReceivedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSelectionReceivedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSelectionReceivedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSelectionReceivedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSelectionReceivedFieldInfo = (~)Gtk.Callbacks.WidgetClassSelectionReceivedFieldCallback
    type AttrTransferType WidgetClassSelectionReceivedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSelectionReceivedFieldCallback)
    type AttrGetType WidgetClassSelectionReceivedFieldInfo = Maybe Gtk.Callbacks.WidgetClassSelectionReceivedFieldCallback
    type AttrLabel WidgetClassSelectionReceivedFieldInfo = "selection_received"
    type AttrOrigin WidgetClassSelectionReceivedFieldInfo = WidgetClass
    attrGet = getWidgetClassSelectionReceived
    attrSet = setWidgetClassSelectionReceived
    attrConstruct = undefined
    attrClear = clearWidgetClassSelectionReceived
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSelectionReceivedFieldCallback (Gtk.Callbacks.wrap_WidgetClassSelectionReceivedFieldCallback Nothing v)

widgetClass_selectionReceived :: AttrLabelProxy "selectionReceived"
widgetClass_selectionReceived = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_begin@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragBegin 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragBegin :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback -> m ()
setWidgetClassDragBegin :: WidgetClass -> FunPtr C_WidgetClassDragBeginFieldCallback -> m ()
setWidgetClassDragBegin WidgetClass
s FunPtr C_WidgetClassDragBeginFieldCallback
val = IO () -> m ()
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_WidgetClassDragBeginFieldCallback)
-> FunPtr C_WidgetClassDragBeginFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
600) (FunPtr C_WidgetClassDragBeginFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback)

-- | Set the value of the “@drag_begin@” 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' #dragBegin
-- @
clearWidgetClassDragBegin :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragBegin :: WidgetClass -> m ()
clearWidgetClassDragBegin WidgetClass
s = IO () -> m ()
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_WidgetClassDragBeginFieldCallback)
-> FunPtr C_WidgetClassDragBeginFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
600) (FunPtr C_WidgetClassDragBeginFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragBeginFieldInfo
instance AttrInfo WidgetClassDragBeginFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragBeginFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragBeginFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragBeginFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragBeginFieldInfo = (~)Gtk.Callbacks.WidgetClassDragBeginFieldCallback
    type AttrTransferType WidgetClassDragBeginFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback)
    type AttrGetType WidgetClassDragBeginFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragBeginFieldCallback
    type AttrLabel WidgetClassDragBeginFieldInfo = "drag_begin"
    type AttrOrigin WidgetClassDragBeginFieldInfo = WidgetClass
    attrGet = getWidgetClassDragBegin
    attrSet = setWidgetClassDragBegin
    attrConstruct = undefined
    attrClear = clearWidgetClassDragBegin
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragBeginFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragBeginFieldCallback Nothing v)

widgetClass_dragBegin :: AttrLabelProxy "dragBegin"
widgetClass_dragBegin = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_end@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragEnd 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragEnd :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback -> m ()
setWidgetClassDragEnd :: WidgetClass -> FunPtr C_WidgetClassDragBeginFieldCallback -> m ()
setWidgetClassDragEnd WidgetClass
s FunPtr C_WidgetClassDragBeginFieldCallback
val = IO () -> m ()
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_WidgetClassDragBeginFieldCallback)
-> FunPtr C_WidgetClassDragBeginFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
608) (FunPtr C_WidgetClassDragBeginFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback)

-- | Set the value of the “@drag_end@” 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' #dragEnd
-- @
clearWidgetClassDragEnd :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragEnd :: WidgetClass -> m ()
clearWidgetClassDragEnd WidgetClass
s = IO () -> m ()
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_WidgetClassDragBeginFieldCallback)
-> FunPtr C_WidgetClassDragBeginFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
608) (FunPtr C_WidgetClassDragBeginFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragEndFieldInfo
instance AttrInfo WidgetClassDragEndFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragEndFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragEndFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragEndFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragEndFieldInfo = (~)Gtk.Callbacks.WidgetClassDragEndFieldCallback
    type AttrTransferType WidgetClassDragEndFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback)
    type AttrGetType WidgetClassDragEndFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragEndFieldCallback
    type AttrLabel WidgetClassDragEndFieldInfo = "drag_end"
    type AttrOrigin WidgetClassDragEndFieldInfo = WidgetClass
    attrGet = getWidgetClassDragEnd
    attrSet = setWidgetClassDragEnd
    attrConstruct = undefined
    attrClear = clearWidgetClassDragEnd
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragEndFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragEndFieldCallback Nothing v)

widgetClass_dragEnd :: AttrLabelProxy "dragEnd"
widgetClass_dragEnd = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_data_get@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragDataGet 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragDataGet :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback -> m ()
setWidgetClassDragDataGet :: WidgetClass -> FunPtr C_WidgetClassDragDataGetFieldCallback -> m ()
setWidgetClassDragDataGet WidgetClass
s FunPtr C_WidgetClassDragDataGetFieldCallback
val = IO () -> m ()
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_WidgetClassDragDataGetFieldCallback)
-> FunPtr C_WidgetClassDragDataGetFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragDataGetFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
616) (FunPtr C_WidgetClassDragDataGetFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback)

-- | Set the value of the “@drag_data_get@” 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' #dragDataGet
-- @
clearWidgetClassDragDataGet :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDataGet :: WidgetClass -> m ()
clearWidgetClassDragDataGet WidgetClass
s = IO () -> m ()
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_WidgetClassDragDataGetFieldCallback)
-> FunPtr C_WidgetClassDragDataGetFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragDataGetFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
616) (FunPtr C_WidgetClassDragDataGetFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragDataGetFieldInfo
instance AttrInfo WidgetClassDragDataGetFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragDataGetFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragDataGetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragDataGetFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragDataGetFieldInfo = (~)Gtk.Callbacks.WidgetClassDragDataGetFieldCallback
    type AttrTransferType WidgetClassDragDataGetFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback)
    type AttrGetType WidgetClassDragDataGetFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragDataGetFieldCallback
    type AttrLabel WidgetClassDragDataGetFieldInfo = "drag_data_get"
    type AttrOrigin WidgetClassDragDataGetFieldInfo = WidgetClass
    attrGet = getWidgetClassDragDataGet
    attrSet = setWidgetClassDragDataGet
    attrConstruct = undefined
    attrClear = clearWidgetClassDragDataGet
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragDataGetFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragDataGetFieldCallback Nothing v)

widgetClass_dragDataGet :: AttrLabelProxy "dragDataGet"
widgetClass_dragDataGet = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_data_delete@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragDataDelete 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback -> m ()
setWidgetClassDragDataDelete :: WidgetClass -> FunPtr C_WidgetClassDragBeginFieldCallback -> m ()
setWidgetClassDragDataDelete WidgetClass
s FunPtr C_WidgetClassDragBeginFieldCallback
val = IO () -> m ()
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_WidgetClassDragBeginFieldCallback)
-> FunPtr C_WidgetClassDragBeginFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
624) (FunPtr C_WidgetClassDragBeginFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback)

-- | Set the value of the “@drag_data_delete@” 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' #dragDataDelete
-- @
clearWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDataDelete :: WidgetClass -> m ()
clearWidgetClassDragDataDelete WidgetClass
s = IO () -> m ()
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_WidgetClassDragBeginFieldCallback)
-> FunPtr C_WidgetClassDragBeginFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
624) (FunPtr C_WidgetClassDragBeginFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragDataDeleteFieldInfo
instance AttrInfo WidgetClassDragDataDeleteFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragDataDeleteFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragDataDeleteFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragDataDeleteFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragDataDeleteFieldInfo = (~)Gtk.Callbacks.WidgetClassDragDataDeleteFieldCallback
    type AttrTransferType WidgetClassDragDataDeleteFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback)
    type AttrGetType WidgetClassDragDataDeleteFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragDataDeleteFieldCallback
    type AttrLabel WidgetClassDragDataDeleteFieldInfo = "drag_data_delete"
    type AttrOrigin WidgetClassDragDataDeleteFieldInfo = WidgetClass
    attrGet = getWidgetClassDragDataDelete
    attrSet = setWidgetClassDragDataDelete
    attrConstruct = undefined
    attrClear = clearWidgetClassDragDataDelete
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragDataDeleteFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragDataDeleteFieldCallback Nothing v)

widgetClass_dragDataDelete :: AttrLabelProxy "dragDataDelete"
widgetClass_dragDataDelete = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_leave@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragLeave 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragLeave :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback -> m ()
setWidgetClassDragLeave :: WidgetClass -> FunPtr C_WidgetClassDragLeaveFieldCallback -> m ()
setWidgetClassDragLeave WidgetClass
s FunPtr C_WidgetClassDragLeaveFieldCallback
val = IO () -> m ()
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_WidgetClassDragLeaveFieldCallback)
-> FunPtr C_WidgetClassDragLeaveFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragLeaveFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
632) (FunPtr C_WidgetClassDragLeaveFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback)

-- | Set the value of the “@drag_leave@” 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' #dragLeave
-- @
clearWidgetClassDragLeave :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragLeave :: WidgetClass -> m ()
clearWidgetClassDragLeave WidgetClass
s = IO () -> m ()
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_WidgetClassDragLeaveFieldCallback)
-> FunPtr C_WidgetClassDragLeaveFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragLeaveFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
632) (FunPtr C_WidgetClassDragLeaveFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragLeaveFieldInfo
instance AttrInfo WidgetClassDragLeaveFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragLeaveFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragLeaveFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragLeaveFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragLeaveFieldInfo = (~)Gtk.Callbacks.WidgetClassDragLeaveFieldCallback
    type AttrTransferType WidgetClassDragLeaveFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback)
    type AttrGetType WidgetClassDragLeaveFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragLeaveFieldCallback
    type AttrLabel WidgetClassDragLeaveFieldInfo = "drag_leave"
    type AttrOrigin WidgetClassDragLeaveFieldInfo = WidgetClass
    attrGet = getWidgetClassDragLeave
    attrSet = setWidgetClassDragLeave
    attrConstruct = undefined
    attrClear = clearWidgetClassDragLeave
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragLeaveFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragLeaveFieldCallback Nothing v)

widgetClass_dragLeave :: AttrLabelProxy "dragLeave"
widgetClass_dragLeave = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_motion@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragMotion 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragMotion :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback -> m ()
setWidgetClassDragMotion :: WidgetClass -> FunPtr C_WidgetClassDragMotionFieldCallback -> m ()
setWidgetClassDragMotion WidgetClass
s FunPtr C_WidgetClassDragMotionFieldCallback
val = IO () -> m ()
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_WidgetClassDragMotionFieldCallback)
-> FunPtr C_WidgetClassDragMotionFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
640) (FunPtr C_WidgetClassDragMotionFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback)

-- | Set the value of the “@drag_motion@” 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' #dragMotion
-- @
clearWidgetClassDragMotion :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragMotion :: WidgetClass -> m ()
clearWidgetClassDragMotion WidgetClass
s = IO () -> m ()
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_WidgetClassDragMotionFieldCallback)
-> FunPtr C_WidgetClassDragMotionFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
640) (FunPtr C_WidgetClassDragMotionFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragMotionFieldInfo
instance AttrInfo WidgetClassDragMotionFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragMotionFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragMotionFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragMotionFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragMotionFieldInfo = (~)Gtk.Callbacks.WidgetClassDragMotionFieldCallback
    type AttrTransferType WidgetClassDragMotionFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback)
    type AttrGetType WidgetClassDragMotionFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragMotionFieldCallback
    type AttrLabel WidgetClassDragMotionFieldInfo = "drag_motion"
    type AttrOrigin WidgetClassDragMotionFieldInfo = WidgetClass
    attrGet = getWidgetClassDragMotion
    attrSet = setWidgetClassDragMotion
    attrConstruct = undefined
    attrClear = clearWidgetClassDragMotion
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragMotionFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragMotionFieldCallback Nothing v)

widgetClass_dragMotion :: AttrLabelProxy "dragMotion"
widgetClass_dragMotion = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_drop@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragDrop 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragDrop :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback -> m ()
setWidgetClassDragDrop :: WidgetClass -> FunPtr C_WidgetClassDragMotionFieldCallback -> m ()
setWidgetClassDragDrop WidgetClass
s FunPtr C_WidgetClassDragMotionFieldCallback
val = IO () -> m ()
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_WidgetClassDragMotionFieldCallback)
-> FunPtr C_WidgetClassDragMotionFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
648) (FunPtr C_WidgetClassDragMotionFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback)

-- | Set the value of the “@drag_drop@” 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' #dragDrop
-- @
clearWidgetClassDragDrop :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDrop :: WidgetClass -> m ()
clearWidgetClassDragDrop WidgetClass
s = IO () -> m ()
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_WidgetClassDragMotionFieldCallback)
-> FunPtr C_WidgetClassDragMotionFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
648) (FunPtr C_WidgetClassDragMotionFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragDropFieldInfo
instance AttrInfo WidgetClassDragDropFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragDropFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragDropFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragDropFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragDropFieldInfo = (~)Gtk.Callbacks.WidgetClassDragDropFieldCallback
    type AttrTransferType WidgetClassDragDropFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback)
    type AttrGetType WidgetClassDragDropFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragDropFieldCallback
    type AttrLabel WidgetClassDragDropFieldInfo = "drag_drop"
    type AttrOrigin WidgetClassDragDropFieldInfo = WidgetClass
    attrGet = getWidgetClassDragDrop
    attrSet = setWidgetClassDragDrop
    attrConstruct = undefined
    attrClear = clearWidgetClassDragDrop
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragDropFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragDropFieldCallback Nothing v)

widgetClass_dragDrop :: AttrLabelProxy "dragDrop"
widgetClass_dragDrop = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_data_received@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragDataReceived 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback -> m ()
setWidgetClassDragDataReceived :: WidgetClass
-> FunPtr C_WidgetClassDragDataReceivedFieldCallback -> m ()
setWidgetClassDragDataReceived WidgetClass
s FunPtr C_WidgetClassDragDataReceivedFieldCallback
val = IO () -> m ()
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_WidgetClassDragDataReceivedFieldCallback)
-> FunPtr C_WidgetClassDragDataReceivedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragDataReceivedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
656) (FunPtr C_WidgetClassDragDataReceivedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback)

-- | Set the value of the “@drag_data_received@” 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' #dragDataReceived
-- @
clearWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDataReceived :: WidgetClass -> m ()
clearWidgetClassDragDataReceived WidgetClass
s = IO () -> m ()
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_WidgetClassDragDataReceivedFieldCallback)
-> FunPtr C_WidgetClassDragDataReceivedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragDataReceivedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
656) (FunPtr C_WidgetClassDragDataReceivedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragDataReceivedFieldInfo
instance AttrInfo WidgetClassDragDataReceivedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragDataReceivedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragDataReceivedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragDataReceivedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragDataReceivedFieldInfo = (~)Gtk.Callbacks.WidgetClassDragDataReceivedFieldCallback
    type AttrTransferType WidgetClassDragDataReceivedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback)
    type AttrGetType WidgetClassDragDataReceivedFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragDataReceivedFieldCallback
    type AttrLabel WidgetClassDragDataReceivedFieldInfo = "drag_data_received"
    type AttrOrigin WidgetClassDragDataReceivedFieldInfo = WidgetClass
    attrGet = getWidgetClassDragDataReceived
    attrSet = setWidgetClassDragDataReceived
    attrConstruct = undefined
    attrClear = clearWidgetClassDragDataReceived
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragDataReceivedFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragDataReceivedFieldCallback Nothing v)

widgetClass_dragDataReceived :: AttrLabelProxy "dragDataReceived"
widgetClass_dragDataReceived = AttrLabelProxy

#endif


-- | Get the value of the “@drag_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 #dragFailed
-- @
getWidgetClassDragFailed :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDragFailedFieldCallback)
getWidgetClassDragFailed :: WidgetClass -> m (Maybe WidgetClassDragFailedFieldCallback)
getWidgetClassDragFailed WidgetClass
s = IO (Maybe WidgetClassDragFailedFieldCallback)
-> m (Maybe WidgetClassDragFailedFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDragFailedFieldCallback)
 -> m (Maybe WidgetClassDragFailedFieldCallback))
-> IO (Maybe WidgetClassDragFailedFieldCallback)
-> m (Maybe WidgetClassDragFailedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassDragFailedFieldCallback))
-> IO (Maybe WidgetClassDragFailedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDragFailedFieldCallback))
 -> IO (Maybe WidgetClassDragFailedFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassDragFailedFieldCallback))
-> IO (Maybe WidgetClassDragFailedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDragFailedFieldCallback
val <- Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)
-> IO (FunPtr C_WidgetClassDragFailedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
664) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback)
    Maybe WidgetClassDragFailedFieldCallback
result <- FunPtr C_WidgetClassDragFailedFieldCallback
-> (FunPtr C_WidgetClassDragFailedFieldCallback
    -> IO WidgetClassDragFailedFieldCallback)
-> IO (Maybe WidgetClassDragFailedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDragFailedFieldCallback
val ((FunPtr C_WidgetClassDragFailedFieldCallback
  -> IO WidgetClassDragFailedFieldCallback)
 -> IO (Maybe WidgetClassDragFailedFieldCallback))
-> (FunPtr C_WidgetClassDragFailedFieldCallback
    -> IO WidgetClassDragFailedFieldCallback)
-> IO (Maybe WidgetClassDragFailedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDragFailedFieldCallback
val' -> do
        let val'' :: WidgetClassDragFailedFieldCallback
val'' = FunPtr C_WidgetClassDragFailedFieldCallback
-> WidgetClassDragFailedFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsDragContext b) =>
FunPtr C_WidgetClassDragFailedFieldCallback
-> a -> b -> DragResult -> m Bool
Gtk.Callbacks.dynamic_WidgetClassDragFailedFieldCallback FunPtr C_WidgetClassDragFailedFieldCallback
val'
        WidgetClassDragFailedFieldCallback
-> IO WidgetClassDragFailedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDragFailedFieldCallback
val''
    Maybe WidgetClassDragFailedFieldCallback
-> IO (Maybe WidgetClassDragFailedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDragFailedFieldCallback
result

-- | Set the value of the “@drag_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 [ #dragFailed 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragFailed :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback -> m ()
setWidgetClassDragFailed :: WidgetClass -> FunPtr C_WidgetClassDragFailedFieldCallback -> m ()
setWidgetClassDragFailed WidgetClass
s FunPtr C_WidgetClassDragFailedFieldCallback
val = IO () -> m ()
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_WidgetClassDragFailedFieldCallback)
-> FunPtr C_WidgetClassDragFailedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
664) (FunPtr C_WidgetClassDragFailedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback)

-- | Set the value of the “@drag_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' #dragFailed
-- @
clearWidgetClassDragFailed :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragFailed :: WidgetClass -> m ()
clearWidgetClassDragFailed WidgetClass
s = IO () -> m ()
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_WidgetClassDragFailedFieldCallback)
-> FunPtr C_WidgetClassDragFailedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
664) (FunPtr C_WidgetClassDragFailedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragFailedFieldInfo
instance AttrInfo WidgetClassDragFailedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragFailedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragFailedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragFailedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragFailedFieldInfo = (~)Gtk.Callbacks.WidgetClassDragFailedFieldCallback
    type AttrTransferType WidgetClassDragFailedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback)
    type AttrGetType WidgetClassDragFailedFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragFailedFieldCallback
    type AttrLabel WidgetClassDragFailedFieldInfo = "drag_failed"
    type AttrOrigin WidgetClassDragFailedFieldInfo = WidgetClass
    attrGet = getWidgetClassDragFailed
    attrSet = setWidgetClassDragFailed
    attrConstruct = undefined
    attrClear = clearWidgetClassDragFailed
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragFailedFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragFailedFieldCallback Nothing v)

widgetClass_dragFailed :: AttrLabelProxy "dragFailed"
widgetClass_dragFailed = AttrLabelProxy

#endif


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

-- | Set the value of the “@popup_menu@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #popupMenu 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassPopupMenu :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback -> m ()
setWidgetClassPopupMenu :: WidgetClass -> FunPtr C_WidgetClassPopupMenuFieldCallback -> m ()
setWidgetClassPopupMenu WidgetClass
s FunPtr C_WidgetClassPopupMenuFieldCallback
val = IO () -> m ()
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_WidgetClassPopupMenuFieldCallback)
-> FunPtr C_WidgetClassPopupMenuFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassPopupMenuFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
672) (FunPtr C_WidgetClassPopupMenuFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback)

-- | Set the value of the “@popup_menu@” 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' #popupMenu
-- @
clearWidgetClassPopupMenu :: MonadIO m => WidgetClass -> m ()
clearWidgetClassPopupMenu :: WidgetClass -> m ()
clearWidgetClassPopupMenu WidgetClass
s = IO () -> m ()
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_WidgetClassPopupMenuFieldCallback)
-> FunPtr C_WidgetClassPopupMenuFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassPopupMenuFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
672) (FunPtr C_WidgetClassPopupMenuFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassPopupMenuFieldInfo
instance AttrInfo WidgetClassPopupMenuFieldInfo where
    type AttrBaseTypeConstraint WidgetClassPopupMenuFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassPopupMenuFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassPopupMenuFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback)
    type AttrTransferTypeConstraint WidgetClassPopupMenuFieldInfo = (~)Gtk.Callbacks.WidgetClassPopupMenuFieldCallback
    type AttrTransferType WidgetClassPopupMenuFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback)
    type AttrGetType WidgetClassPopupMenuFieldInfo = Maybe Gtk.Callbacks.WidgetClassPopupMenuFieldCallback
    type AttrLabel WidgetClassPopupMenuFieldInfo = "popup_menu"
    type AttrOrigin WidgetClassPopupMenuFieldInfo = WidgetClass
    attrGet = getWidgetClassPopupMenu
    attrSet = setWidgetClassPopupMenu
    attrConstruct = undefined
    attrClear = clearWidgetClassPopupMenu
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassPopupMenuFieldCallback (Gtk.Callbacks.wrap_WidgetClassPopupMenuFieldCallback Nothing v)

widgetClass_popupMenu :: AttrLabelProxy "popupMenu"
widgetClass_popupMenu = AttrLabelProxy

#endif


-- | Get the value of the “@show_help@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #showHelp
-- @
getWidgetClassShowHelp :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassShowHelpFieldCallback)
getWidgetClassShowHelp :: WidgetClass -> m (Maybe WidgetClassShowHelpFieldCallback)
getWidgetClassShowHelp WidgetClass
s = IO (Maybe WidgetClassShowHelpFieldCallback)
-> m (Maybe WidgetClassShowHelpFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowHelpFieldCallback)
 -> m (Maybe WidgetClassShowHelpFieldCallback))
-> IO (Maybe WidgetClassShowHelpFieldCallback)
-> m (Maybe WidgetClassShowHelpFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowHelpFieldCallback))
-> IO (Maybe WidgetClassShowHelpFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowHelpFieldCallback))
 -> IO (Maybe WidgetClassShowHelpFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowHelpFieldCallback))
-> IO (Maybe WidgetClassShowHelpFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassFocusFieldCallback
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
680) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassShowHelpFieldCallback)
    Maybe WidgetClassShowHelpFieldCallback
result <- FunPtr C_WidgetClassFocusFieldCallback
-> (FunPtr C_WidgetClassFocusFieldCallback
    -> IO WidgetClassShowHelpFieldCallback)
-> IO (Maybe WidgetClassShowHelpFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassFocusFieldCallback
val ((FunPtr C_WidgetClassFocusFieldCallback
  -> IO WidgetClassShowHelpFieldCallback)
 -> IO (Maybe WidgetClassShowHelpFieldCallback))
-> (FunPtr C_WidgetClassFocusFieldCallback
    -> IO WidgetClassShowHelpFieldCallback)
-> IO (Maybe WidgetClassShowHelpFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassFocusFieldCallback
val' -> do
        let val'' :: WidgetClassShowHelpFieldCallback
val'' = FunPtr C_WidgetClassFocusFieldCallback
-> WidgetClassShowHelpFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassFocusFieldCallback
-> a -> WidgetHelpType -> m Bool
Gtk.Callbacks.dynamic_WidgetClassShowHelpFieldCallback FunPtr C_WidgetClassFocusFieldCallback
val'
        WidgetClassShowHelpFieldCallback
-> IO WidgetClassShowHelpFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowHelpFieldCallback
val''
    Maybe WidgetClassShowHelpFieldCallback
-> IO (Maybe WidgetClassShowHelpFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassShowHelpFieldCallback
result

-- | Set the value of the “@show_help@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #showHelp 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassShowHelp :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassShowHelpFieldCallback -> m ()
setWidgetClassShowHelp :: WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassShowHelp WidgetClass
s FunPtr C_WidgetClassFocusFieldCallback
val = IO () -> m ()
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
680) (FunPtr C_WidgetClassFocusFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassShowHelpFieldCallback)

-- | Set the value of the “@show_help@” 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' #showHelp
-- @
clearWidgetClassShowHelp :: MonadIO m => WidgetClass -> m ()
clearWidgetClassShowHelp :: WidgetClass -> m ()
clearWidgetClassShowHelp WidgetClass
s = IO () -> m ()
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
680) (FunPtr C_WidgetClassFocusFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassShowHelpFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassShowHelpFieldInfo
instance AttrInfo WidgetClassShowHelpFieldInfo where
    type AttrBaseTypeConstraint WidgetClassShowHelpFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassShowHelpFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassShowHelpFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassShowHelpFieldCallback)
    type AttrTransferTypeConstraint WidgetClassShowHelpFieldInfo = (~)Gtk.Callbacks.WidgetClassShowHelpFieldCallback
    type AttrTransferType WidgetClassShowHelpFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassShowHelpFieldCallback)
    type AttrGetType WidgetClassShowHelpFieldInfo = Maybe Gtk.Callbacks.WidgetClassShowHelpFieldCallback
    type AttrLabel WidgetClassShowHelpFieldInfo = "show_help"
    type AttrOrigin WidgetClassShowHelpFieldInfo = WidgetClass
    attrGet = getWidgetClassShowHelp
    attrSet = setWidgetClassShowHelp
    attrConstruct = undefined
    attrClear = clearWidgetClassShowHelp
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassShowHelpFieldCallback (Gtk.Callbacks.wrap_WidgetClassShowHelpFieldCallback Nothing v)

widgetClass_showHelp :: AttrLabelProxy "showHelp"
widgetClass_showHelp = AttrLabelProxy

#endif


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

-- | Set the value of the “@get_accessible@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #getAccessible 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGetAccessible :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback -> m ()
setWidgetClassGetAccessible :: WidgetClass
-> FunPtr C_WidgetClassGetAccessibleFieldCallback -> m ()
setWidgetClassGetAccessible WidgetClass
s FunPtr C_WidgetClassGetAccessibleFieldCallback
val = IO () -> m ()
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_WidgetClassGetAccessibleFieldCallback)
-> FunPtr C_WidgetClassGetAccessibleFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetAccessibleFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
688) (FunPtr C_WidgetClassGetAccessibleFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback)

-- | Set the value of the “@get_accessible@” 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' #getAccessible
-- @
clearWidgetClassGetAccessible :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetAccessible :: WidgetClass -> m ()
clearWidgetClassGetAccessible WidgetClass
s = IO () -> m ()
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_WidgetClassGetAccessibleFieldCallback)
-> FunPtr C_WidgetClassGetAccessibleFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetAccessibleFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
688) (FunPtr C_WidgetClassGetAccessibleFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetAccessibleFieldInfo
instance AttrInfo WidgetClassGetAccessibleFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGetAccessibleFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGetAccessibleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGetAccessibleFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGetAccessibleFieldInfo = (~)Gtk.Callbacks.WidgetClassGetAccessibleFieldCallback
    type AttrTransferType WidgetClassGetAccessibleFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback)
    type AttrGetType WidgetClassGetAccessibleFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetAccessibleFieldCallback
    type AttrLabel WidgetClassGetAccessibleFieldInfo = "get_accessible"
    type AttrOrigin WidgetClassGetAccessibleFieldInfo = WidgetClass
    attrGet = getWidgetClassGetAccessible
    attrSet = setWidgetClassGetAccessible
    attrConstruct = undefined
    attrClear = clearWidgetClassGetAccessible
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGetAccessibleFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetAccessibleFieldCallback Nothing v)

widgetClass_getAccessible :: AttrLabelProxy "getAccessible"
widgetClass_getAccessible = AttrLabelProxy

#endif


-- | Get the value of the “@screen_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 #screenChanged
-- @
getWidgetClassScreenChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassScreenChangedFieldCallback)
getWidgetClassScreenChanged :: WidgetClass -> m (Maybe WidgetClassScreenChangedFieldCallback)
getWidgetClassScreenChanged WidgetClass
s = IO (Maybe WidgetClassScreenChangedFieldCallback)
-> m (Maybe WidgetClassScreenChangedFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassScreenChangedFieldCallback)
 -> m (Maybe WidgetClassScreenChangedFieldCallback))
-> IO (Maybe WidgetClassScreenChangedFieldCallback)
-> m (Maybe WidgetClassScreenChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassScreenChangedFieldCallback))
-> IO (Maybe WidgetClassScreenChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassScreenChangedFieldCallback))
 -> IO (Maybe WidgetClassScreenChangedFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassScreenChangedFieldCallback))
-> IO (Maybe WidgetClassScreenChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassScreenChangedFieldCallback
val <- Ptr (FunPtr C_WidgetClassScreenChangedFieldCallback)
-> IO (FunPtr C_WidgetClassScreenChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassScreenChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
696) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassScreenChangedFieldCallback)
    Maybe WidgetClassScreenChangedFieldCallback
result <- FunPtr C_WidgetClassScreenChangedFieldCallback
-> (FunPtr C_WidgetClassScreenChangedFieldCallback
    -> IO WidgetClassScreenChangedFieldCallback)
-> IO (Maybe WidgetClassScreenChangedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassScreenChangedFieldCallback
val ((FunPtr C_WidgetClassScreenChangedFieldCallback
  -> IO WidgetClassScreenChangedFieldCallback)
 -> IO (Maybe WidgetClassScreenChangedFieldCallback))
-> (FunPtr C_WidgetClassScreenChangedFieldCallback
    -> IO WidgetClassScreenChangedFieldCallback)
-> IO (Maybe WidgetClassScreenChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassScreenChangedFieldCallback
val' -> do
        let val'' :: WidgetClassScreenChangedFieldCallback
val'' = FunPtr C_WidgetClassScreenChangedFieldCallback
-> WidgetClassScreenChangedFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsScreen b) =>
FunPtr C_WidgetClassScreenChangedFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_WidgetClassScreenChangedFieldCallback FunPtr C_WidgetClassScreenChangedFieldCallback
val'
        WidgetClassScreenChangedFieldCallback
-> IO WidgetClassScreenChangedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassScreenChangedFieldCallback
val''
    Maybe WidgetClassScreenChangedFieldCallback
-> IO (Maybe WidgetClassScreenChangedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassScreenChangedFieldCallback
result

-- | Set the value of the “@screen_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 [ #screenChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassScreenChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassScreenChangedFieldCallback -> m ()
setWidgetClassScreenChanged :: WidgetClass
-> FunPtr C_WidgetClassScreenChangedFieldCallback -> m ()
setWidgetClassScreenChanged WidgetClass
s FunPtr C_WidgetClassScreenChangedFieldCallback
val = IO () -> m ()
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_WidgetClassScreenChangedFieldCallback)
-> FunPtr C_WidgetClassScreenChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassScreenChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
696) (FunPtr C_WidgetClassScreenChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassScreenChangedFieldCallback)

-- | Set the value of the “@screen_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' #screenChanged
-- @
clearWidgetClassScreenChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassScreenChanged :: WidgetClass -> m ()
clearWidgetClassScreenChanged WidgetClass
s = IO () -> m ()
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_WidgetClassScreenChangedFieldCallback)
-> FunPtr C_WidgetClassScreenChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassScreenChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
696) (FunPtr C_WidgetClassScreenChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassScreenChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassScreenChangedFieldInfo
instance AttrInfo WidgetClassScreenChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassScreenChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassScreenChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassScreenChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassScreenChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassScreenChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassScreenChangedFieldCallback
    type AttrTransferType WidgetClassScreenChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassScreenChangedFieldCallback)
    type AttrGetType WidgetClassScreenChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassScreenChangedFieldCallback
    type AttrLabel WidgetClassScreenChangedFieldInfo = "screen_changed"
    type AttrOrigin WidgetClassScreenChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassScreenChanged
    attrSet = setWidgetClassScreenChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassScreenChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassScreenChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassScreenChangedFieldCallback Nothing v)

widgetClass_screenChanged :: AttrLabelProxy "screenChanged"
widgetClass_screenChanged = AttrLabelProxy

#endif


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

-- | Set the value of the “@can_activate_accel@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #canActivateAccel 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback -> m ()
setWidgetClassCanActivateAccel :: WidgetClass
-> FunPtr C_WidgetClassCanActivateAccelFieldCallback -> m ()
setWidgetClassCanActivateAccel WidgetClass
s FunPtr C_WidgetClassCanActivateAccelFieldCallback
val = IO () -> m ()
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_WidgetClassCanActivateAccelFieldCallback)
-> FunPtr C_WidgetClassCanActivateAccelFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassCanActivateAccelFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
704) (FunPtr C_WidgetClassCanActivateAccelFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback)

-- | Set the value of the “@can_activate_accel@” 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' #canActivateAccel
-- @
clearWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> m ()
clearWidgetClassCanActivateAccel :: WidgetClass -> m ()
clearWidgetClassCanActivateAccel WidgetClass
s = IO () -> m ()
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_WidgetClassCanActivateAccelFieldCallback)
-> FunPtr C_WidgetClassCanActivateAccelFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassCanActivateAccelFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
704) (FunPtr C_WidgetClassCanActivateAccelFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassCanActivateAccelFieldInfo
instance AttrInfo WidgetClassCanActivateAccelFieldInfo where
    type AttrBaseTypeConstraint WidgetClassCanActivateAccelFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassCanActivateAccelFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassCanActivateAccelFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback)
    type AttrTransferTypeConstraint WidgetClassCanActivateAccelFieldInfo = (~)Gtk.Callbacks.WidgetClassCanActivateAccelFieldCallback
    type AttrTransferType WidgetClassCanActivateAccelFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback)
    type AttrGetType WidgetClassCanActivateAccelFieldInfo = Maybe Gtk.Callbacks.WidgetClassCanActivateAccelFieldCallback
    type AttrLabel WidgetClassCanActivateAccelFieldInfo = "can_activate_accel"
    type AttrOrigin WidgetClassCanActivateAccelFieldInfo = WidgetClass
    attrGet = getWidgetClassCanActivateAccel
    attrSet = setWidgetClassCanActivateAccel
    attrConstruct = undefined
    attrClear = clearWidgetClassCanActivateAccel
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassCanActivateAccelFieldCallback (Gtk.Callbacks.wrap_WidgetClassCanActivateAccelFieldCallback Nothing v)

widgetClass_canActivateAccel :: AttrLabelProxy "canActivateAccel"
widgetClass_canActivateAccel = AttrLabelProxy

#endif


-- | Get the value of the “@composited_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 #compositedChanged
-- @
getWidgetClassCompositedChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassCompositedChangedFieldCallback)
getWidgetClassCompositedChanged :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassCompositedChanged WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
712) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassCompositedChangedFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassCompositedChangedFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result

-- | Set the value of the “@composited_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 [ #compositedChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassCompositedChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassCompositedChangedFieldCallback -> m ()
setWidgetClassCompositedChanged :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassCompositedChanged WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
712) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassCompositedChangedFieldCallback)

-- | Set the value of the “@composited_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' #compositedChanged
-- @
clearWidgetClassCompositedChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassCompositedChanged :: WidgetClass -> m ()
clearWidgetClassCompositedChanged WidgetClass
s = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
712) (FunPtr C_WidgetClassDestroyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassCompositedChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassCompositedChangedFieldInfo
instance AttrInfo WidgetClassCompositedChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassCompositedChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassCompositedChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassCompositedChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassCompositedChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassCompositedChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassCompositedChangedFieldCallback
    type AttrTransferType WidgetClassCompositedChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassCompositedChangedFieldCallback)
    type AttrGetType WidgetClassCompositedChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassCompositedChangedFieldCallback
    type AttrLabel WidgetClassCompositedChangedFieldInfo = "composited_changed"
    type AttrOrigin WidgetClassCompositedChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassCompositedChanged
    attrSet = setWidgetClassCompositedChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassCompositedChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassCompositedChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassCompositedChangedFieldCallback Nothing v)

widgetClass_compositedChanged :: AttrLabelProxy "compositedChanged"
widgetClass_compositedChanged = 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 :: WidgetClass -> m (Maybe WidgetClassQueryTooltipFieldCallback)
getWidgetClassQueryTooltip WidgetClass
s = IO (Maybe WidgetClassQueryTooltipFieldCallback)
-> m (Maybe WidgetClassQueryTooltipFieldCallback)
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
    FunPtr C_WidgetClassQueryTooltipFieldCallback
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
720) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)
    Maybe WidgetClassQueryTooltipFieldCallback
result <- FunPtr C_WidgetClassQueryTooltipFieldCallback
-> (FunPtr C_WidgetClassQueryTooltipFieldCallback
    -> IO WidgetClassQueryTooltipFieldCallback)
-> IO (Maybe WidgetClassQueryTooltipFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassQueryTooltipFieldCallback
val ((FunPtr C_WidgetClassQueryTooltipFieldCallback
  -> IO WidgetClassQueryTooltipFieldCallback)
 -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
-> (FunPtr C_WidgetClassQueryTooltipFieldCallback
    -> IO WidgetClassQueryTooltipFieldCallback)
-> IO (Maybe WidgetClassQueryTooltipFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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 (m :: * -> *) a. Monad m => a -> m a
return WidgetClassQueryTooltipFieldCallback
val''
    Maybe WidgetClassQueryTooltipFieldCallback
-> IO (Maybe WidgetClassQueryTooltipFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassQueryTooltipFieldCallback
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 :: WidgetClass
-> FunPtr C_WidgetClassQueryTooltipFieldCallback -> m ()
setWidgetClassQueryTooltip WidgetClass
s FunPtr C_WidgetClassQueryTooltipFieldCallback
val = IO () -> m ()
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
720) (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 :: WidgetClass -> m ()
clearWidgetClassQueryTooltip WidgetClass
s = IO () -> m ()
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
720) (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)

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 :: WidgetClass -> m (Maybe WidgetClassComputeExpandFieldCallback)
getWidgetClassComputeExpand WidgetClass
s = IO (Maybe WidgetClassComputeExpandFieldCallback)
-> m (Maybe WidgetClassComputeExpandFieldCallback)
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
    FunPtr C_WidgetClassComputeExpandFieldCallback
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
728) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)
    Maybe WidgetClassComputeExpandFieldCallback
result <- FunPtr C_WidgetClassComputeExpandFieldCallback
-> (FunPtr C_WidgetClassComputeExpandFieldCallback
    -> IO WidgetClassComputeExpandFieldCallback)
-> IO (Maybe WidgetClassComputeExpandFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassComputeExpandFieldCallback
val ((FunPtr C_WidgetClassComputeExpandFieldCallback
  -> IO WidgetClassComputeExpandFieldCallback)
 -> IO (Maybe WidgetClassComputeExpandFieldCallback))
-> (FunPtr C_WidgetClassComputeExpandFieldCallback
    -> IO WidgetClassComputeExpandFieldCallback)
-> IO (Maybe WidgetClassComputeExpandFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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 (m :: * -> *) a. Monad m => a -> m a
return WidgetClassComputeExpandFieldCallback
val''
    Maybe WidgetClassComputeExpandFieldCallback
-> IO (Maybe WidgetClassComputeExpandFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassComputeExpandFieldCallback
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 :: WidgetClass
-> FunPtr C_WidgetClassComputeExpandFieldCallback -> m ()
setWidgetClassComputeExpand WidgetClass
s FunPtr C_WidgetClassComputeExpandFieldCallback
val = IO () -> m ()
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
728) (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 :: WidgetClass -> m ()
clearWidgetClassComputeExpand WidgetClass
s = IO () -> m ()
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
728) (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)

widgetClass_computeExpand :: AttrLabelProxy "computeExpand"
widgetClass_computeExpand = AttrLabelProxy

#endif


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

-- | Set the value of the “@adjust_size_request@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #adjustSizeRequest 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassAdjustSizeRequest :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeRequestFieldCallback -> m ()
setWidgetClassAdjustSizeRequest :: WidgetClass
-> FunPtr C_WidgetClassAdjustSizeRequestFieldCallback -> m ()
setWidgetClassAdjustSizeRequest WidgetClass
s FunPtr C_WidgetClassAdjustSizeRequestFieldCallback
val = IO () -> m ()
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_WidgetClassAdjustSizeRequestFieldCallback)
-> FunPtr C_WidgetClassAdjustSizeRequestFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
736) (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeRequestFieldCallback)

-- | Set the value of the “@adjust_size_request@” 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' #adjustSizeRequest
-- @
clearWidgetClassAdjustSizeRequest :: MonadIO m => WidgetClass -> m ()
clearWidgetClassAdjustSizeRequest :: WidgetClass -> m ()
clearWidgetClassAdjustSizeRequest WidgetClass
s = IO () -> m ()
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_WidgetClassAdjustSizeRequestFieldCallback)
-> FunPtr C_WidgetClassAdjustSizeRequestFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
736) (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeRequestFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassAdjustSizeRequestFieldInfo
instance AttrInfo WidgetClassAdjustSizeRequestFieldInfo where
    type AttrBaseTypeConstraint WidgetClassAdjustSizeRequestFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassAdjustSizeRequestFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassAdjustSizeRequestFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeRequestFieldCallback)
    type AttrTransferTypeConstraint WidgetClassAdjustSizeRequestFieldInfo = (~)Gtk.Callbacks.WidgetClassAdjustSizeRequestFieldCallback
    type AttrTransferType WidgetClassAdjustSizeRequestFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeRequestFieldCallback)
    type AttrGetType WidgetClassAdjustSizeRequestFieldInfo = Maybe Gtk.Callbacks.WidgetClassAdjustSizeRequestFieldCallback
    type AttrLabel WidgetClassAdjustSizeRequestFieldInfo = "adjust_size_request"
    type AttrOrigin WidgetClassAdjustSizeRequestFieldInfo = WidgetClass
    attrGet = getWidgetClassAdjustSizeRequest
    attrSet = setWidgetClassAdjustSizeRequest
    attrConstruct = undefined
    attrClear = clearWidgetClassAdjustSizeRequest
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassAdjustSizeRequestFieldCallback (Gtk.Callbacks.wrap_WidgetClassAdjustSizeRequestFieldCallback Nothing v)

widgetClass_adjustSizeRequest :: AttrLabelProxy "adjustSizeRequest"
widgetClass_adjustSizeRequest = AttrLabelProxy

#endif


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

-- | Set the value of the “@adjust_size_allocation@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #adjustSizeAllocation 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassAdjustSizeAllocation :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeAllocationFieldCallback -> m ()
setWidgetClassAdjustSizeAllocation :: WidgetClass
-> FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback -> m ()
setWidgetClassAdjustSizeAllocation WidgetClass
s FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback
val = IO () -> m ()
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_WidgetClassAdjustSizeAllocationFieldCallback)
-> FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
744) (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeAllocationFieldCallback)

-- | Set the value of the “@adjust_size_allocation@” 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' #adjustSizeAllocation
-- @
clearWidgetClassAdjustSizeAllocation :: MonadIO m => WidgetClass -> m ()
clearWidgetClassAdjustSizeAllocation :: WidgetClass -> m ()
clearWidgetClassAdjustSizeAllocation WidgetClass
s = IO () -> m ()
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_WidgetClassAdjustSizeAllocationFieldCallback)
-> FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
744) (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeAllocationFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassAdjustSizeAllocationFieldInfo
instance AttrInfo WidgetClassAdjustSizeAllocationFieldInfo where
    type AttrBaseTypeConstraint WidgetClassAdjustSizeAllocationFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassAdjustSizeAllocationFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassAdjustSizeAllocationFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeAllocationFieldCallback)
    type AttrTransferTypeConstraint WidgetClassAdjustSizeAllocationFieldInfo = (~)Gtk.Callbacks.WidgetClassAdjustSizeAllocationFieldCallback
    type AttrTransferType WidgetClassAdjustSizeAllocationFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeAllocationFieldCallback)
    type AttrGetType WidgetClassAdjustSizeAllocationFieldInfo = Maybe Gtk.Callbacks.WidgetClassAdjustSizeAllocationFieldCallback
    type AttrLabel WidgetClassAdjustSizeAllocationFieldInfo = "adjust_size_allocation"
    type AttrOrigin WidgetClassAdjustSizeAllocationFieldInfo = WidgetClass
    attrGet = getWidgetClassAdjustSizeAllocation
    attrSet = setWidgetClassAdjustSizeAllocation
    attrConstruct = undefined
    attrClear = clearWidgetClassAdjustSizeAllocation
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassAdjustSizeAllocationFieldCallback (Gtk.Callbacks.wrap_WidgetClassAdjustSizeAllocationFieldCallback Nothing v)

widgetClass_adjustSizeAllocation :: AttrLabelProxy "adjustSizeAllocation"
widgetClass_adjustSizeAllocation = AttrLabelProxy

#endif


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

-- | Set the value of the “@style_updated@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #styleUpdated 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback -> m ()
setWidgetClassStyleUpdated :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassStyleUpdated WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
752) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback)

-- | Set the value of the “@style_updated@” 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' #styleUpdated
-- @
clearWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> m ()
clearWidgetClassStyleUpdated :: WidgetClass -> m ()
clearWidgetClassStyleUpdated WidgetClass
s = IO () -> m ()
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_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
752) (FunPtr C_WidgetClassDestroyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassStyleUpdatedFieldInfo
instance AttrInfo WidgetClassStyleUpdatedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassStyleUpdatedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassStyleUpdatedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassStyleUpdatedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassStyleUpdatedFieldInfo = (~)Gtk.Callbacks.WidgetClassStyleUpdatedFieldCallback
    type AttrTransferType WidgetClassStyleUpdatedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback)
    type AttrGetType WidgetClassStyleUpdatedFieldInfo = Maybe Gtk.Callbacks.WidgetClassStyleUpdatedFieldCallback
    type AttrLabel WidgetClassStyleUpdatedFieldInfo = "style_updated"
    type AttrOrigin WidgetClassStyleUpdatedFieldInfo = WidgetClass
    attrGet = getWidgetClassStyleUpdated
    attrSet = setWidgetClassStyleUpdated
    attrConstruct = undefined
    attrClear = clearWidgetClassStyleUpdated
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassStyleUpdatedFieldCallback (Gtk.Callbacks.wrap_WidgetClassStyleUpdatedFieldCallback Nothing v)

widgetClass_styleUpdated :: AttrLabelProxy "styleUpdated"
widgetClass_styleUpdated = AttrLabelProxy

#endif


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

-- | Set the value of the “@touch_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #touchEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassTouchEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassTouchEventFieldCallback -> m ()
setWidgetClassTouchEvent :: WidgetClass -> FunPtr C_WidgetClassTouchEventFieldCallback -> m ()
setWidgetClassTouchEvent WidgetClass
s FunPtr C_WidgetClassTouchEventFieldCallback
val = IO () -> m ()
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_WidgetClassTouchEventFieldCallback)
-> FunPtr C_WidgetClassTouchEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassTouchEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
760) (FunPtr C_WidgetClassTouchEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassTouchEventFieldCallback)

-- | Set the value of the “@touch_event@” 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' #touchEvent
-- @
clearWidgetClassTouchEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassTouchEvent :: WidgetClass -> m ()
clearWidgetClassTouchEvent WidgetClass
s = IO () -> m ()
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_WidgetClassTouchEventFieldCallback)
-> FunPtr C_WidgetClassTouchEventFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassTouchEventFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
760) (FunPtr C_WidgetClassTouchEventFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassTouchEventFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassTouchEventFieldInfo
instance AttrInfo WidgetClassTouchEventFieldInfo where
    type AttrBaseTypeConstraint WidgetClassTouchEventFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassTouchEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassTouchEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassTouchEventFieldCallback)
    type AttrTransferTypeConstraint WidgetClassTouchEventFieldInfo = (~)Gtk.Callbacks.WidgetClassTouchEventFieldCallback
    type AttrTransferType WidgetClassTouchEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassTouchEventFieldCallback)
    type AttrGetType WidgetClassTouchEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassTouchEventFieldCallback
    type AttrLabel WidgetClassTouchEventFieldInfo = "touch_event"
    type AttrOrigin WidgetClassTouchEventFieldInfo = WidgetClass
    attrGet = getWidgetClassTouchEvent
    attrSet = setWidgetClassTouchEvent
    attrConstruct = undefined
    attrClear = clearWidgetClassTouchEvent
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassTouchEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassTouchEventFieldCallback Nothing v)

widgetClass_touchEvent :: AttrLabelProxy "touchEvent"
widgetClass_touchEvent = AttrLabelProxy

#endif


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

-- | Set the value of the “@get_preferred_height_and_baseline_for_width@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #getPreferredHeightAndBaselineForWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGetPreferredHeightAndBaselineForWidth :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> m ()
setWidgetClassGetPreferredHeightAndBaselineForWidth :: WidgetClass
-> FunPtr
     C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
-> m ()
setWidgetClassGetPreferredHeightAndBaselineForWidth WidgetClass
s FunPtr
  C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
val = IO () -> m ()
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_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
-> FunPtr
     C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr
     (FunPtr
        C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
768) (FunPtr
  C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)

-- | Set the value of the “@get_preferred_height_and_baseline_for_width@” 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' #getPreferredHeightAndBaselineForWidth
-- @
clearWidgetClassGetPreferredHeightAndBaselineForWidth :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredHeightAndBaselineForWidth :: WidgetClass -> m ()
clearWidgetClassGetPreferredHeightAndBaselineForWidth WidgetClass
s = IO () -> m ()
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_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
-> FunPtr
     C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr
     (FunPtr
        C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
768) (FunPtr
  C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo
instance AttrInfo WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = (~)Gtk.Callbacks.WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
    type AttrTransferType WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
    type AttrGetType WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
    type AttrLabel WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = "get_preferred_height_and_baseline_for_width"
    type AttrOrigin WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = WidgetClass
    attrGet = getWidgetClassGetPreferredHeightAndBaselineForWidth
    attrSet = setWidgetClassGetPreferredHeightAndBaselineForWidth
    attrConstruct = undefined
    attrClear = clearWidgetClassGetPreferredHeightAndBaselineForWidth
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback Nothing v)

widgetClass_getPreferredHeightAndBaselineForWidth :: AttrLabelProxy "getPreferredHeightAndBaselineForWidth"
widgetClass_getPreferredHeightAndBaselineForWidth = AttrLabelProxy

#endif


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

-- | Set the value of the “@adjust_baseline_request@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #adjustBaselineRequest 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassAdjustBaselineRequest :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineRequestFieldCallback -> m ()
setWidgetClassAdjustBaselineRequest :: WidgetClass
-> FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback -> m ()
setWidgetClassAdjustBaselineRequest WidgetClass
s FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback
val = IO () -> m ()
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_WidgetClassAdjustBaselineRequestFieldCallback)
-> FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
776) (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineRequestFieldCallback)

-- | Set the value of the “@adjust_baseline_request@” 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' #adjustBaselineRequest
-- @
clearWidgetClassAdjustBaselineRequest :: MonadIO m => WidgetClass -> m ()
clearWidgetClassAdjustBaselineRequest :: WidgetClass -> m ()
clearWidgetClassAdjustBaselineRequest WidgetClass
s = IO () -> m ()
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_WidgetClassAdjustBaselineRequestFieldCallback)
-> FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
776) (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineRequestFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassAdjustBaselineRequestFieldInfo
instance AttrInfo WidgetClassAdjustBaselineRequestFieldInfo where
    type AttrBaseTypeConstraint WidgetClassAdjustBaselineRequestFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassAdjustBaselineRequestFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassAdjustBaselineRequestFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineRequestFieldCallback)
    type AttrTransferTypeConstraint WidgetClassAdjustBaselineRequestFieldInfo = (~)Gtk.Callbacks.WidgetClassAdjustBaselineRequestFieldCallback
    type AttrTransferType WidgetClassAdjustBaselineRequestFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineRequestFieldCallback)
    type AttrGetType WidgetClassAdjustBaselineRequestFieldInfo = Maybe Gtk.Callbacks.WidgetClassAdjustBaselineRequestFieldCallback
    type AttrLabel WidgetClassAdjustBaselineRequestFieldInfo = "adjust_baseline_request"
    type AttrOrigin WidgetClassAdjustBaselineRequestFieldInfo = WidgetClass
    attrGet = getWidgetClassAdjustBaselineRequest
    attrSet = setWidgetClassAdjustBaselineRequest
    attrConstruct = undefined
    attrClear = clearWidgetClassAdjustBaselineRequest
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassAdjustBaselineRequestFieldCallback (Gtk.Callbacks.wrap_WidgetClassAdjustBaselineRequestFieldCallback Nothing v)

widgetClass_adjustBaselineRequest :: AttrLabelProxy "adjustBaselineRequest"
widgetClass_adjustBaselineRequest = AttrLabelProxy

#endif


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

-- | Set the value of the “@adjust_baseline_allocation@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #adjustBaselineAllocation 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassAdjustBaselineAllocation :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineAllocationFieldCallback -> m ()
setWidgetClassAdjustBaselineAllocation :: WidgetClass
-> FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
-> m ()
setWidgetClassAdjustBaselineAllocation WidgetClass
s FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
val = IO () -> m ()
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_WidgetClassAdjustBaselineAllocationFieldCallback)
-> FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
784) (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineAllocationFieldCallback)

-- | Set the value of the “@adjust_baseline_allocation@” 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' #adjustBaselineAllocation
-- @
clearWidgetClassAdjustBaselineAllocation :: MonadIO m => WidgetClass -> m ()
clearWidgetClassAdjustBaselineAllocation :: WidgetClass -> m ()
clearWidgetClassAdjustBaselineAllocation WidgetClass
s = IO () -> m ()
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_WidgetClassAdjustBaselineAllocationFieldCallback)
-> FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
-> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int
-> Ptr (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
784) (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineAllocationFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassAdjustBaselineAllocationFieldInfo
instance AttrInfo WidgetClassAdjustBaselineAllocationFieldInfo where
    type AttrBaseTypeConstraint WidgetClassAdjustBaselineAllocationFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassAdjustBaselineAllocationFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassAdjustBaselineAllocationFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineAllocationFieldCallback)
    type AttrTransferTypeConstraint WidgetClassAdjustBaselineAllocationFieldInfo = (~)Gtk.Callbacks.WidgetClassAdjustBaselineAllocationFieldCallback
    type AttrTransferType WidgetClassAdjustBaselineAllocationFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineAllocationFieldCallback)
    type AttrGetType WidgetClassAdjustBaselineAllocationFieldInfo = Maybe Gtk.Callbacks.WidgetClassAdjustBaselineAllocationFieldCallback
    type AttrLabel WidgetClassAdjustBaselineAllocationFieldInfo = "adjust_baseline_allocation"
    type AttrOrigin WidgetClassAdjustBaselineAllocationFieldInfo = WidgetClass
    attrGet = getWidgetClassAdjustBaselineAllocation
    attrSet = setWidgetClassAdjustBaselineAllocation
    attrConstruct = undefined
    attrClear = clearWidgetClassAdjustBaselineAllocation
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassAdjustBaselineAllocationFieldCallback (Gtk.Callbacks.wrap_WidgetClassAdjustBaselineAllocationFieldCallback Nothing v)

widgetClass_adjustBaselineAllocation :: AttrLabelProxy "adjustBaselineAllocation"
widgetClass_adjustBaselineAllocation = AttrLabelProxy

#endif


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

-- | Set the value of the “@queue_draw_region@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #queueDrawRegion 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassQueueDrawRegion :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassQueueDrawRegionFieldCallback -> m ()
setWidgetClassQueueDrawRegion :: WidgetClass
-> FunPtr C_WidgetClassQueueDrawRegionFieldCallback -> m ()
setWidgetClassQueueDrawRegion WidgetClass
s FunPtr C_WidgetClassQueueDrawRegionFieldCallback
val = IO () -> m ()
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_WidgetClassQueueDrawRegionFieldCallback)
-> FunPtr C_WidgetClassQueueDrawRegionFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassQueueDrawRegionFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
792) (FunPtr C_WidgetClassQueueDrawRegionFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassQueueDrawRegionFieldCallback)

-- | Set the value of the “@queue_draw_region@” 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' #queueDrawRegion
-- @
clearWidgetClassQueueDrawRegion :: MonadIO m => WidgetClass -> m ()
clearWidgetClassQueueDrawRegion :: WidgetClass -> m ()
clearWidgetClassQueueDrawRegion WidgetClass
s = IO () -> m ()
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_WidgetClassQueueDrawRegionFieldCallback)
-> FunPtr C_WidgetClassQueueDrawRegionFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassQueueDrawRegionFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
792) (FunPtr C_WidgetClassQueueDrawRegionFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassQueueDrawRegionFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassQueueDrawRegionFieldInfo
instance AttrInfo WidgetClassQueueDrawRegionFieldInfo where
    type AttrBaseTypeConstraint WidgetClassQueueDrawRegionFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassQueueDrawRegionFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassQueueDrawRegionFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassQueueDrawRegionFieldCallback)
    type AttrTransferTypeConstraint WidgetClassQueueDrawRegionFieldInfo = (~)Gtk.Callbacks.WidgetClassQueueDrawRegionFieldCallback
    type AttrTransferType WidgetClassQueueDrawRegionFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassQueueDrawRegionFieldCallback)
    type AttrGetType WidgetClassQueueDrawRegionFieldInfo = Maybe Gtk.Callbacks.WidgetClassQueueDrawRegionFieldCallback
    type AttrLabel WidgetClassQueueDrawRegionFieldInfo = "queue_draw_region"
    type AttrOrigin WidgetClassQueueDrawRegionFieldInfo = WidgetClass
    attrGet = getWidgetClassQueueDrawRegion
    attrSet = setWidgetClassQueueDrawRegion
    attrConstruct = undefined
    attrClear = clearWidgetClassQueueDrawRegion
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassQueueDrawRegionFieldCallback (Gtk.Callbacks.wrap_WidgetClassQueueDrawRegionFieldCallback Nothing v)

widgetClass_queueDrawRegion :: AttrLabelProxy "queueDrawRegion"
widgetClass_queueDrawRegion = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList WidgetClass
type instance O.AttributeList WidgetClass = WidgetClassAttributeList
type WidgetClassAttributeList = ('[ '("parentClass", WidgetClassParentClassFieldInfo), '("activateSignal", WidgetClassActivateSignalFieldInfo), '("dispatchChildPropertiesChanged", WidgetClassDispatchChildPropertiesChangedFieldInfo), '("destroy", WidgetClassDestroyFieldInfo), '("show", WidgetClassShowFieldInfo), '("showAll", WidgetClassShowAllFieldInfo), '("hide", WidgetClassHideFieldInfo), '("map", WidgetClassMapFieldInfo), '("unmap", WidgetClassUnmapFieldInfo), '("realize", WidgetClassRealizeFieldInfo), '("unrealize", WidgetClassUnrealizeFieldInfo), '("sizeAllocate", WidgetClassSizeAllocateFieldInfo), '("stateChanged", WidgetClassStateChangedFieldInfo), '("stateFlagsChanged", WidgetClassStateFlagsChangedFieldInfo), '("parentSet", WidgetClassParentSetFieldInfo), '("hierarchyChanged", WidgetClassHierarchyChangedFieldInfo), '("styleSet", WidgetClassStyleSetFieldInfo), '("directionChanged", WidgetClassDirectionChangedFieldInfo), '("grabNotify", WidgetClassGrabNotifyFieldInfo), '("childNotify", WidgetClassChildNotifyFieldInfo), '("draw", WidgetClassDrawFieldInfo), '("getRequestMode", WidgetClassGetRequestModeFieldInfo), '("getPreferredHeight", WidgetClassGetPreferredHeightFieldInfo), '("getPreferredWidthForHeight", WidgetClassGetPreferredWidthForHeightFieldInfo), '("getPreferredWidth", WidgetClassGetPreferredWidthFieldInfo), '("getPreferredHeightForWidth", WidgetClassGetPreferredHeightForWidthFieldInfo), '("mnemonicActivate", WidgetClassMnemonicActivateFieldInfo), '("grabFocus", WidgetClassGrabFocusFieldInfo), '("focus", WidgetClassFocusFieldInfo), '("moveFocus", WidgetClassMoveFocusFieldInfo), '("keynavFailed", WidgetClassKeynavFailedFieldInfo), '("event", WidgetClassEventFieldInfo), '("buttonPressEvent", WidgetClassButtonPressEventFieldInfo), '("buttonReleaseEvent", WidgetClassButtonReleaseEventFieldInfo), '("scrollEvent", WidgetClassScrollEventFieldInfo), '("motionNotifyEvent", WidgetClassMotionNotifyEventFieldInfo), '("deleteEvent", WidgetClassDeleteEventFieldInfo), '("destroyEvent", WidgetClassDestroyEventFieldInfo), '("keyPressEvent", WidgetClassKeyPressEventFieldInfo), '("keyReleaseEvent", WidgetClassKeyReleaseEventFieldInfo), '("enterNotifyEvent", WidgetClassEnterNotifyEventFieldInfo), '("leaveNotifyEvent", WidgetClassLeaveNotifyEventFieldInfo), '("configureEvent", WidgetClassConfigureEventFieldInfo), '("focusInEvent", WidgetClassFocusInEventFieldInfo), '("focusOutEvent", WidgetClassFocusOutEventFieldInfo), '("mapEvent", WidgetClassMapEventFieldInfo), '("unmapEvent", WidgetClassUnmapEventFieldInfo), '("propertyNotifyEvent", WidgetClassPropertyNotifyEventFieldInfo), '("selectionClearEvent", WidgetClassSelectionClearEventFieldInfo), '("selectionRequestEvent", WidgetClassSelectionRequestEventFieldInfo), '("selectionNotifyEvent", WidgetClassSelectionNotifyEventFieldInfo), '("proximityInEvent", WidgetClassProximityInEventFieldInfo), '("proximityOutEvent", WidgetClassProximityOutEventFieldInfo), '("visibilityNotifyEvent", WidgetClassVisibilityNotifyEventFieldInfo), '("windowStateEvent", WidgetClassWindowStateEventFieldInfo), '("damageEvent", WidgetClassDamageEventFieldInfo), '("grabBrokenEvent", WidgetClassGrabBrokenEventFieldInfo), '("selectionGet", WidgetClassSelectionGetFieldInfo), '("selectionReceived", WidgetClassSelectionReceivedFieldInfo), '("dragBegin", WidgetClassDragBeginFieldInfo), '("dragEnd", WidgetClassDragEndFieldInfo), '("dragDataGet", WidgetClassDragDataGetFieldInfo), '("dragDataDelete", WidgetClassDragDataDeleteFieldInfo), '("dragLeave", WidgetClassDragLeaveFieldInfo), '("dragMotion", WidgetClassDragMotionFieldInfo), '("dragDrop", WidgetClassDragDropFieldInfo), '("dragDataReceived", WidgetClassDragDataReceivedFieldInfo), '("dragFailed", WidgetClassDragFailedFieldInfo), '("popupMenu", WidgetClassPopupMenuFieldInfo), '("showHelp", WidgetClassShowHelpFieldInfo), '("getAccessible", WidgetClassGetAccessibleFieldInfo), '("screenChanged", WidgetClassScreenChangedFieldInfo), '("canActivateAccel", WidgetClassCanActivateAccelFieldInfo), '("compositedChanged", WidgetClassCompositedChangedFieldInfo), '("queryTooltip", WidgetClassQueryTooltipFieldInfo), '("computeExpand", WidgetClassComputeExpandFieldInfo), '("adjustSizeRequest", WidgetClassAdjustSizeRequestFieldInfo), '("adjustSizeAllocation", WidgetClassAdjustSizeAllocationFieldInfo), '("styleUpdated", WidgetClassStyleUpdatedFieldInfo), '("touchEvent", WidgetClassTouchEventFieldInfo), '("getPreferredHeightAndBaselineForWidth", WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo), '("adjustBaselineRequest", WidgetClassAdjustBaselineRequestFieldInfo), '("adjustBaselineAllocation", WidgetClassAdjustBaselineAllocationFieldInfo), '("queueDrawRegion", WidgetClassQueueDrawRegionFieldInfo)] :: [(Symbol, *)])
#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 #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The name of the callback as expected in the template XML"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = 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
--           , 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 ()

-- | Declares a /@callbackSymbol@/ to handle /@callbackName@/ from the template XML
-- defined for /@widgetType@/. See 'GI.Gtk.Objects.Builder.builderAddCallbackSymbol'.
-- 
-- Note that this must be called from a composite widget classes class
-- initializer after calling 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
-- 
-- /Since: 3.10/
widgetClassBindTemplateCallbackFull ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: A t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> T.Text
    -- ^ /@callbackName@/: The name of the callback as expected in the template XML
    -> GObject.Callbacks.Callback
    -- ^ /@callbackSymbol@/: The callback symbol
    -> m ()
widgetClassBindTemplateCallbackFull :: WidgetClass -> Text -> IO () -> m ()
widgetClassBindTemplateCallbackFull WidgetClass
widgetClass Text
callbackName IO ()
callbackSymbol = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
callbackName' <- Text -> IO CString
textToCString Text
callbackName
    Ptr (FunPtr (IO ()))
ptrcallbackSymbol <- IO (Ptr (FunPtr (IO ())))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GObject.Callbacks.C_Callback))
    FunPtr (IO ())
callbackSymbol' <- IO () -> IO (FunPtr (IO ()))
GObject.Callbacks.mk_Callback (Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
GObject.Callbacks.wrap_Callback (Ptr (FunPtr (IO ())) -> Maybe (Ptr (FunPtr (IO ())))
forall a. a -> Maybe a
Just Ptr (FunPtr (IO ()))
ptrcallbackSymbol) IO ()
callbackSymbol)
    Ptr (FunPtr (IO ())) -> FunPtr (IO ()) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr (IO ()))
ptrcallbackSymbol FunPtr (IO ())
callbackSymbol'
    Ptr WidgetClass -> CString -> FunPtr (IO ()) -> IO ()
gtk_widget_class_bind_template_callback_full Ptr WidgetClass
widgetClass' CString
callbackName' FunPtr (IO ())
callbackSymbol'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
callbackName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassBindTemplateCallbackFullMethodInfo
instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> m ()), MonadIO m) => O.MethodInfo WidgetClassBindTemplateCallbackFullMethodInfo WidgetClass signature where
    overloadedMethod = 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 #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The \8220id\8221 of the child defined in the template XML"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = 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
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "struct_offset"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The structure offset into the composite widget\8217s instance public or private structure\n                where the automated child pointer should be set, or 0 to not assign the pointer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = 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
    Int64 ->                                -- struct_offset : TBasicType TInt64
    IO ()

-- | Automatically assign 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 t'GI.GObject.Structs.ObjectClass.ObjectClass'.@/dispose/@() runs
-- on your instance and if a /@structOffset@/ that is != 0 is specified, then the automatic location
-- in your instance public or private data will be set to 'P.Nothing'. You can however access an automated child
-- pointer the first time your classes t'GI.GObject.Structs.ObjectClass.ObjectClass'.@/dispose/@() runs, or alternatively in
-- t'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/destroy/@().
-- 
-- If /@internalChild@/ is specified, t'GI.Gtk.Structs.BuildableIface.BuildableIface'.@/get_internal_child/@() will be automatically
-- implemented by the t'GI.Gtk.Objects.Widget.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'.
-- 
-- /Since: 3.10/
widgetClassBindTemplateChildFull ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: A t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> T.Text
    -- ^ /@name@/: The “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
    -> Int64
    -- ^ /@structOffset@/: The structure 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 :: WidgetClass -> Text -> Bool -> Int64 -> m ()
widgetClassBindTemplateChildFull WidgetClass
widgetClass Text
name Bool
internalChild Int64
structOffset = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
name' <- Text -> IO CString
textToCString Text
name
    let internalChild' :: CInt
internalChild' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
internalChild
    Ptr WidgetClass -> CString -> CInt -> Int64 -> IO ()
gtk_widget_class_bind_template_child_full Ptr WidgetClass
widgetClass' CString
name' CInt
internalChild' Int64
structOffset
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

#endif

-- method WidgetClass::find_style_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "klass"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the style property to find"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TParamSpec
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_find_style_property" gtk_widget_class_find_style_property :: 
    Ptr WidgetClass ->                      -- klass : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- property_name : TBasicType TUTF8
    IO (Ptr GParamSpec)

-- | Finds a style property of a widget class by name.
-- 
-- /Since: 2.2/
widgetClassFindStyleProperty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@klass@/: a t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> T.Text
    -- ^ /@propertyName@/: the name of the style property to find
    -> m GParamSpec
    -- ^ __Returns:__ the t'GI.GObject.Objects.ParamSpec.ParamSpec' of the style property or
    --   'P.Nothing' if /@class@/ has no style property with that name.
widgetClassFindStyleProperty :: WidgetClass -> Text -> m GParamSpec
widgetClassFindStyleProperty WidgetClass
klass Text
propertyName = IO GParamSpec -> m GParamSpec
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GParamSpec -> m GParamSpec) -> IO GParamSpec -> m GParamSpec
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
klass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
klass
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr GParamSpec
result <- Ptr WidgetClass -> CString -> IO (Ptr GParamSpec)
gtk_widget_class_find_style_property Ptr WidgetClass
klass' CString
propertyName'
    Text -> Ptr GParamSpec -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"widgetClassFindStyleProperty" Ptr GParamSpec
result
    GParamSpec
result' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
result
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
klass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    GParamSpec -> IO GParamSpec
forall (m :: * -> *) a. Monad m => a -> m a
return GParamSpec
result'

#if defined(ENABLE_OVERLOADING)
data WidgetClassFindStylePropertyMethodInfo
instance (signature ~ (T.Text -> m GParamSpec), MonadIO m) => O.MethodInfo WidgetClassFindStylePropertyMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassFindStyleProperty

#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
--           , 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.
-- 
-- /Since: 3.20/
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 :: WidgetClass -> m Text
widgetClassGetCssName WidgetClass
widgetClass = IO Text -> m Text
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
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
result <- Ptr WidgetClass -> IO CString
gtk_widget_class_get_css_name Ptr WidgetClass
widgetClass'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"widgetClassGetCssName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

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

#endif

-- method WidgetClass::install_style_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "klass"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GParamSpec for the property"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_install_style_property" gtk_widget_class_install_style_property :: 
    Ptr WidgetClass ->                      -- klass : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO ()

-- | Installs a style property on a widget class. The parser for the
-- style property is determined by the value type of /@pspec@/.
widgetClassInstallStyleProperty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@klass@/: a t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> GParamSpec
    -- ^ /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' for the property
    -> m ()
widgetClassInstallStyleProperty :: WidgetClass -> GParamSpec -> m ()
widgetClassInstallStyleProperty WidgetClass
klass GParamSpec
pspec = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
klass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
klass
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr WidgetClass -> Ptr GParamSpec -> IO ()
gtk_widget_class_install_style_property Ptr WidgetClass
klass' Ptr GParamSpec
pspec'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
klass
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassInstallStylePropertyMethodInfo
instance (signature ~ (GParamSpec -> m ()), MonadIO m) => O.MethodInfo WidgetClassInstallStylePropertyMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassInstallStyleProperty

#endif

-- XXX Could not generate method WidgetClass::list_style_properties
-- Not implemented: unpackCArray : Don't know how to unpack C Array of type TParamSpec
-- 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 "class to set the accessible role for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "role"
--           , argType = TInterface Name { namespace = "Atk" , name = "Role" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The role to use for accessibles created for @widget_class"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = 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 ->                                -- role : TInterface (Name {namespace = "Atk", name = "Role"})
    IO ()

-- | Sets the default t'GI.Atk.Enums.Role' to be set on accessibles created for
-- widgets of /@widgetClass@/. Accessibles may decide to not honor this
-- setting if their role reporting is more refined. Calls to
-- 'GI.Gtk.Structs.WidgetClass.widgetClassSetAccessibleType' will reset this value.
-- 
-- In cases where you want more fine-grained control over the role of
-- accessibles created for /@widgetClass@/, you should provide your own
-- accessible type and use 'GI.Gtk.Structs.WidgetClass.widgetClassSetAccessibleType'
-- instead.
-- 
-- If /@role@/ is @/ATK_ROLE_INVALID/@, the default role will not be changed
-- and the accessible’s default role will be used instead.
-- 
-- This function should only be called from class init functions of widgets.
-- 
-- /Since: 3.2/
widgetClassSetAccessibleRole ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: class to set the accessible role for
    -> Atk.Enums.Role
    -- ^ /@role@/: The role to use for accessibles created for /@widgetClass@/
    -> m ()
widgetClassSetAccessibleRole :: WidgetClass -> Role -> m ()
widgetClassSetAccessibleRole WidgetClass
widgetClass Role
role = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    let role' :: CUInt
role' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Role -> Int) -> Role -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Role -> Int
forall a. Enum a => a -> Int
fromEnum) Role
role
    Ptr WidgetClass -> CUInt -> IO ()
gtk_widget_class_set_accessible_role Ptr WidgetClass
widgetClass' CUInt
role'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

#endif

-- method WidgetClass::set_accessible_type
-- 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 accessible type for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The object type that implements the accessible for @widget_class"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the type to be used for creating accessibles for widgets of
-- /@widgetClass@/. The given /@type@/ must be a subtype of the type used for
-- accessibles of the parent class.
-- 
-- This function should only be called from class init functions of widgets.
-- 
-- /Since: 3.2/
widgetClassSetAccessibleType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: class to set the accessible type for
    -> GType
    -- ^ /@type@/: The object type that implements the accessible for /@widgetClass@/
    -> m ()
widgetClassSetAccessibleType :: WidgetClass -> GType -> m ()
widgetClassSetAccessibleType WidgetClass
widgetClass GType
type_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    let type_' :: CGType
type_' = GType -> CGType
gtypeToCGType GType
type_
    Ptr WidgetClass -> CGType -> IO ()
gtk_widget_class_set_accessible_type Ptr WidgetClass
widgetClass' CGType
type_'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetAccessibleTypeMethodInfo
instance (signature ~ (GType -> m ()), MonadIO m) => O.MethodInfo WidgetClassSetAccessibleTypeMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetAccessibleType

#endif

-- method WidgetClass::set_connect_func
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connect_func"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "BuilderConnectFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The #GtkBuilderConnectFunc to use when connecting signals in the class template"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = 2
--           , argDestroy = 3
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connect_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The data to pass to @connect_func"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connect_data_destroy"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The #GDestroyNotify to free @connect_data, this will only be used at\n                       class finalization time, when no classes of type @widget_type are in use anymore."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_set_connect_func" gtk_widget_class_set_connect_func :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    FunPtr Gtk.Callbacks.C_BuilderConnectFunc -> -- connect_func : TInterface (Name {namespace = "Gtk", name = "BuilderConnectFunc"})
    Ptr () ->                               -- connect_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- connect_data_destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

-- | For use in language bindings, this will override the default t'GI.Gtk.Callbacks.BuilderConnectFunc' to be
-- used when parsing GtkBuilder XML from this class’s template data.
-- 
-- Note that this must be called from a composite widget classes class
-- initializer after calling 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
-- 
-- /Since: 3.10/
widgetClassSetConnectFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: A t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> Gtk.Callbacks.BuilderConnectFunc
    -- ^ /@connectFunc@/: The t'GI.Gtk.Callbacks.BuilderConnectFunc' to use when connecting signals in the class template
    -> m ()
widgetClassSetConnectFunc :: WidgetClass -> BuilderConnectFunc -> m ()
widgetClassSetConnectFunc WidgetClass
widgetClass BuilderConnectFunc
connectFunc = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    FunPtr C_BuilderConnectFunc
connectFunc' <- C_BuilderConnectFunc -> IO (FunPtr C_BuilderConnectFunc)
Gtk.Callbacks.mk_BuilderConnectFunc (Maybe (Ptr (FunPtr C_BuilderConnectFunc))
-> BuilderConnectFunc_WithClosures -> C_BuilderConnectFunc
Gtk.Callbacks.wrap_BuilderConnectFunc Maybe (Ptr (FunPtr C_BuilderConnectFunc))
forall a. Maybe a
Nothing (BuilderConnectFunc -> BuilderConnectFunc_WithClosures
Gtk.Callbacks.drop_closures_BuilderConnectFunc BuilderConnectFunc
connectFunc))
    let connectData :: Ptr ()
connectData = FunPtr C_BuilderConnectFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_BuilderConnectFunc
connectFunc'
    let connectDataDestroy :: FunPtr (Ptr a -> IO ())
connectDataDestroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
    Ptr WidgetClass
-> FunPtr C_BuilderConnectFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gtk_widget_class_set_connect_func Ptr WidgetClass
widgetClass' FunPtr C_BuilderConnectFunc
connectFunc' Ptr ()
connectData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
connectDataDestroy
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetConnectFuncMethodInfo
instance (signature ~ (Gtk.Callbacks.BuilderConnectFunc -> m ()), MonadIO m) => O.MethodInfo WidgetClassSetConnectFuncMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetConnectFunc

#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
--           , 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
--           , 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
-- of the parent class is used.
-- 
-- /Since: 3.20/
widgetClassSetCssName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: class to set the name on
    -> T.Text
    -- ^ /@name@/: name to use
    -> m ()
widgetClassSetCssName :: WidgetClass -> Text -> m ()
widgetClassSetCssName WidgetClass
widgetClass Text
name = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr WidgetClass -> CString -> IO ()
gtk_widget_class_set_css_name Ptr WidgetClass
widgetClass' CString
name'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

#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 #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "template_bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GBytes holding the #GtkBuilder XML"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = 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.
-- 
-- /Since: 3.10/
widgetClassSetTemplate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: A t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> GLib.Bytes.Bytes
    -- ^ /@templateBytes@/: A t'GI.GLib.Structs.Bytes.Bytes' holding the t'GI.Gtk.Objects.Builder.Builder' XML
    -> m ()
widgetClassSetTemplate :: WidgetClass -> Bytes -> m ()
widgetClassSetTemplate WidgetClass
widgetClass Bytes
templateBytes = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    Ptr Bytes
templateBytes' <- Bytes -> IO (Ptr Bytes)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
templateBytes
    Ptr WidgetClass -> Ptr Bytes -> IO ()
gtk_widget_class_set_template Ptr WidgetClass
widgetClass' Ptr Bytes
templateBytes'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    Bytes -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
templateBytes
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetTemplateMethodInfo
instance (signature ~ (GLib.Bytes.Bytes -> m ()), MonadIO m) => O.MethodInfo WidgetClassSetTemplateMethodInfo WidgetClass signature where
    overloadedMethod = 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 #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "resource_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The name of the resource to load the template from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = 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 to call 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
-- 
-- Note that any class that installs templates must call 'GI.Gtk.Objects.Widget.widgetInitTemplate'
-- in the widget’s instance initializer.
-- 
-- /Since: 3.10/
widgetClassSetTemplateFromResource ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: A t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> T.Text
    -- ^ /@resourceName@/: The name of the resource to load the template from
    -> m ()
widgetClassSetTemplateFromResource :: WidgetClass -> Text -> m ()
widgetClassSetTemplateFromResource WidgetClass
widgetClass Text
resourceName = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
resourceName' <- Text -> IO CString
textToCString Text
resourceName
    Ptr WidgetClass -> CString -> IO ()
gtk_widget_class_set_template_from_resource Ptr WidgetClass
widgetClass' CString
resourceName'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
resourceName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveWidgetClassMethod (t :: Symbol) (o :: *) :: * where
    ResolveWidgetClassMethod "bindTemplateCallbackFull" o = WidgetClassBindTemplateCallbackFullMethodInfo
    ResolveWidgetClassMethod "bindTemplateChildFull" o = WidgetClassBindTemplateChildFullMethodInfo
    ResolveWidgetClassMethod "findStyleProperty" o = WidgetClassFindStylePropertyMethodInfo
    ResolveWidgetClassMethod "installStyleProperty" o = WidgetClassInstallStylePropertyMethodInfo
    ResolveWidgetClassMethod "getCssName" o = WidgetClassGetCssNameMethodInfo
    ResolveWidgetClassMethod "setAccessibleRole" o = WidgetClassSetAccessibleRoleMethodInfo
    ResolveWidgetClassMethod "setAccessibleType" o = WidgetClassSetAccessibleTypeMethodInfo
    ResolveWidgetClassMethod "setConnectFunc" o = WidgetClassSetConnectFuncMethodInfo
    ResolveWidgetClassMethod "setCssName" o = WidgetClassSetCssNameMethodInfo
    ResolveWidgetClassMethod "setTemplate" o = WidgetClassSetTemplateMethodInfo
    ResolveWidgetClassMethod "setTemplateFromResource" o = WidgetClassSetTemplateFromResourceMethodInfo
    ResolveWidgetClassMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveWidgetClassMethod t WidgetClass, O.MethodInfo 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

#endif