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

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem' is a menu item that maintains the state of a boolean
    -- value in addition to a t'GI.Gtk.Objects.MenuItem.MenuItem' usual role in activating application
    -- code.
    --
    -- A check box indicating the state of the boolean value is displayed
    -- at the left side of the t'GI.Gtk.Objects.MenuItem.MenuItem'.  Activating the t'GI.Gtk.Objects.MenuItem.MenuItem'
    -- toggles the value.
    --
    -- = CSS nodes
    --
    --
    -- === /plain code/
    -- >
    -- >menuitem
    -- >├── check.left
    -- >╰── <child>
    --
    --
    -- GtkCheckMenuItem has a main CSS node with name menuitem, and a subnode
    -- with name check, which gets the .left or .right style class.

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

    module GI.Gtk.Objects.CheckMenuItem
        (

    -- * Exported types
        CheckMenuItem(..)                       ,
        IsCheckMenuItem                         ,
        toCheckMenuItem                         ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [activate]("GI.Gtk.Objects.MenuItem#g:method:activate"), [add]("GI.Gtk.Objects.Container#g:method:add"), [addAccelerator]("GI.Gtk.Objects.Widget#g:method:addAccelerator"), [addChild]("GI.Gtk.Interfaces.Buildable#g:method:addChild"), [addDeviceEvents]("GI.Gtk.Objects.Widget#g:method:addDeviceEvents"), [addEvents]("GI.Gtk.Objects.Widget#g:method:addEvents"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [canActivateAccel]("GI.Gtk.Objects.Widget#g:method:canActivateAccel"), [checkResize]("GI.Gtk.Objects.Container#g:method:checkResize"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [childGetProperty]("GI.Gtk.Objects.Container#g:method:childGetProperty"), [childNotify]("GI.Gtk.Objects.Container#g:method:childNotify"), [childNotifyByPspec]("GI.Gtk.Objects.Container#g:method:childNotifyByPspec"), [childSetProperty]("GI.Gtk.Objects.Container#g:method:childSetProperty"), [childType]("GI.Gtk.Objects.Container#g:method:childType"), [classPath]("GI.Gtk.Objects.Widget#g:method:classPath"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [constructChild]("GI.Gtk.Interfaces.Buildable#g:method:constructChild"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [customFinished]("GI.Gtk.Interfaces.Buildable#g:method:customFinished"), [customTagEnd]("GI.Gtk.Interfaces.Buildable#g:method:customTagEnd"), [customTagStart]("GI.Gtk.Interfaces.Buildable#g:method:customTagStart"), [deselect]("GI.Gtk.Objects.MenuItem#g:method:deselect"), [destroy]("GI.Gtk.Objects.Widget#g:method:destroy"), [destroyed]("GI.Gtk.Objects.Widget#g:method:destroyed"), [deviceIsShadowed]("GI.Gtk.Objects.Widget#g:method:deviceIsShadowed"), [doSetRelatedAction]("GI.Gtk.Interfaces.Activatable#g:method:doSetRelatedAction"), [dragBegin]("GI.Gtk.Objects.Widget#g:method:dragBegin"), [dragBeginWithCoordinates]("GI.Gtk.Objects.Widget#g:method:dragBeginWithCoordinates"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [dragDestAddImageTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddImageTargets"), [dragDestAddTextTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddTextTargets"), [dragDestAddUriTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddUriTargets"), [dragDestFindTarget]("GI.Gtk.Objects.Widget#g:method:dragDestFindTarget"), [dragDestGetTargetList]("GI.Gtk.Objects.Widget#g:method:dragDestGetTargetList"), [dragDestGetTrackMotion]("GI.Gtk.Objects.Widget#g:method:dragDestGetTrackMotion"), [dragDestSet]("GI.Gtk.Objects.Widget#g:method:dragDestSet"), [dragDestSetProxy]("GI.Gtk.Objects.Widget#g:method:dragDestSetProxy"), [dragDestSetTargetList]("GI.Gtk.Objects.Widget#g:method:dragDestSetTargetList"), [dragDestSetTrackMotion]("GI.Gtk.Objects.Widget#g:method:dragDestSetTrackMotion"), [dragDestUnset]("GI.Gtk.Objects.Widget#g:method:dragDestUnset"), [dragGetData]("GI.Gtk.Objects.Widget#g:method:dragGetData"), [dragHighlight]("GI.Gtk.Objects.Widget#g:method:dragHighlight"), [dragSourceAddImageTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddImageTargets"), [dragSourceAddTextTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddTextTargets"), [dragSourceAddUriTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddUriTargets"), [dragSourceGetTargetList]("GI.Gtk.Objects.Widget#g:method:dragSourceGetTargetList"), [dragSourceSet]("GI.Gtk.Objects.Widget#g:method:dragSourceSet"), [dragSourceSetIconGicon]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconGicon"), [dragSourceSetIconName]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconName"), [dragSourceSetIconPixbuf]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconPixbuf"), [dragSourceSetIconStock]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconStock"), [dragSourceSetTargetList]("GI.Gtk.Objects.Widget#g:method:dragSourceSetTargetList"), [dragSourceUnset]("GI.Gtk.Objects.Widget#g:method:dragSourceUnset"), [dragUnhighlight]("GI.Gtk.Objects.Widget#g:method:dragUnhighlight"), [draw]("GI.Gtk.Objects.Widget#g:method:draw"), [ensureStyle]("GI.Gtk.Objects.Widget#g:method:ensureStyle"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [event]("GI.Gtk.Objects.Widget#g:method:event"), [forall]("GI.Gtk.Objects.Container#g:method:forall"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.Gtk.Objects.Container#g:method:foreach"), [freezeChildNotify]("GI.Gtk.Objects.Widget#g:method:freezeChildNotify"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabAdd]("GI.Gtk.Objects.Widget#g:method:grabAdd"), [grabDefault]("GI.Gtk.Objects.Widget#g:method:grabDefault"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [grabRemove]("GI.Gtk.Objects.Widget#g:method:grabRemove"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasGrab]("GI.Gtk.Objects.Widget#g:method:hasGrab"), [hasRcStyle]("GI.Gtk.Objects.Widget#g:method:hasRcStyle"), [hasScreen]("GI.Gtk.Objects.Widget#g:method:hasScreen"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [hideOnDelete]("GI.Gtk.Objects.Widget#g:method:hideOnDelete"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [inputShapeCombineRegion]("GI.Gtk.Objects.Widget#g:method:inputShapeCombineRegion"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [intersect]("GI.Gtk.Objects.Widget#g:method:intersect"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isComposited]("GI.Gtk.Objects.Widget#g:method:isComposited"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isToplevel]("GI.Gtk.Objects.Widget#g:method:isToplevel"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listAccelClosures]("GI.Gtk.Objects.Widget#g:method:listAccelClosures"), [listActionPrefixes]("GI.Gtk.Objects.Widget#g:method:listActionPrefixes"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [modifyBase]("GI.Gtk.Objects.Widget#g:method:modifyBase"), [modifyBg]("GI.Gtk.Objects.Widget#g:method:modifyBg"), [modifyCursor]("GI.Gtk.Objects.Widget#g:method:modifyCursor"), [modifyFg]("GI.Gtk.Objects.Widget#g:method:modifyFg"), [modifyFont]("GI.Gtk.Objects.Widget#g:method:modifyFont"), [modifyStyle]("GI.Gtk.Objects.Widget#g:method:modifyStyle"), [modifyText]("GI.Gtk.Objects.Widget#g:method:modifyText"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [overrideBackgroundColor]("GI.Gtk.Objects.Widget#g:method:overrideBackgroundColor"), [overrideColor]("GI.Gtk.Objects.Widget#g:method:overrideColor"), [overrideCursor]("GI.Gtk.Objects.Widget#g:method:overrideCursor"), [overrideFont]("GI.Gtk.Objects.Widget#g:method:overrideFont"), [overrideSymbolicColor]("GI.Gtk.Objects.Widget#g:method:overrideSymbolicColor"), [parserFinished]("GI.Gtk.Interfaces.Buildable#g:method:parserFinished"), [path]("GI.Gtk.Objects.Widget#g:method:path"), [propagateDraw]("GI.Gtk.Objects.Container#g:method:propagateDraw"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueComputeExpand]("GI.Gtk.Objects.Widget#g:method:queueComputeExpand"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueDrawArea]("GI.Gtk.Objects.Widget#g:method:queueDrawArea"), [queueDrawRegion]("GI.Gtk.Objects.Widget#g:method:queueDrawRegion"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [queueResizeNoRedraw]("GI.Gtk.Objects.Widget#g:method:queueResizeNoRedraw"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [regionIntersect]("GI.Gtk.Objects.Widget#g:method:regionIntersect"), [registerWindow]("GI.Gtk.Objects.Widget#g:method:registerWindow"), [remove]("GI.Gtk.Objects.Container#g:method:remove"), [removeAccelerator]("GI.Gtk.Objects.Widget#g:method:removeAccelerator"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [renderIcon]("GI.Gtk.Objects.Widget#g:method:renderIcon"), [renderIconPixbuf]("GI.Gtk.Objects.Widget#g:method:renderIconPixbuf"), [reparent]("GI.Gtk.Objects.Widget#g:method:reparent"), [resetRcStyles]("GI.Gtk.Objects.Widget#g:method:resetRcStyles"), [resetStyle]("GI.Gtk.Objects.Widget#g:method:resetStyle"), [resizeChildren]("GI.Gtk.Objects.Container#g:method:resizeChildren"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [select]("GI.Gtk.Objects.MenuItem#g:method:select"), [sendExpose]("GI.Gtk.Objects.Widget#g:method:sendExpose"), [sendFocusChange]("GI.Gtk.Objects.Widget#g:method:sendFocusChange"), [shapeCombineRegion]("GI.Gtk.Objects.Widget#g:method:shapeCombineRegion"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [showAll]("GI.Gtk.Objects.Widget#g:method:showAll"), [showNow]("GI.Gtk.Objects.Widget#g:method:showNow"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [sizeAllocateWithBaseline]("GI.Gtk.Objects.Widget#g:method:sizeAllocateWithBaseline"), [sizeRequest]("GI.Gtk.Objects.Widget#g:method:sizeRequest"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [styleAttach]("GI.Gtk.Objects.Widget#g:method:styleAttach"), [styleGetProperty]("GI.Gtk.Objects.Widget#g:method:styleGetProperty"), [syncActionProperties]("GI.Gtk.Interfaces.Activatable#g:method:syncActionProperties"), [thawChildNotify]("GI.Gtk.Objects.Widget#g:method:thawChildNotify"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [toggleSizeAllocate]("GI.Gtk.Objects.MenuItem#g:method:toggleSizeAllocate"), [toggleSizeRequest]("GI.Gtk.Objects.MenuItem#g:method:toggleSizeRequest"), [toggled]("GI.Gtk.Objects.CheckMenuItem#g:method:toggled"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unregisterWindow]("GI.Gtk.Objects.Widget#g:method:unregisterWindow"), [unsetFocusChain]("GI.Gtk.Objects.Container#g:method:unsetFocusChain"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getAccelPath]("GI.Gtk.Objects.MenuItem#g:method:getAccelPath"), [getAccessible]("GI.Gtk.Objects.Widget#g:method:getAccessible"), [getActionGroup]("GI.Gtk.Objects.Widget#g:method:getActionGroup"), [getActionName]("GI.Gtk.Interfaces.Actionable#g:method:getActionName"), [getActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:getActionTargetValue"), [getActive]("GI.Gtk.Objects.CheckMenuItem#g:method:getActive"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedSize]("GI.Gtk.Objects.Widget#g:method:getAllocatedSize"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAppPaintable]("GI.Gtk.Objects.Widget#g:method:getAppPaintable"), [getBorderWidth]("GI.Gtk.Objects.Container#g:method:getBorderWidth"), [getCanDefault]("GI.Gtk.Objects.Widget#g:method:getCanDefault"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getChild]("GI.Gtk.Objects.Bin#g:method:getChild"), [getChildRequisition]("GI.Gtk.Objects.Widget#g:method:getChildRequisition"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getChildren]("GI.Gtk.Objects.Container#g:method:getChildren"), [getClip]("GI.Gtk.Objects.Widget#g:method:getClip"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getCompositeName]("GI.Gtk.Objects.Widget#g:method:getCompositeName"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDeviceEnabled]("GI.Gtk.Objects.Widget#g:method:getDeviceEnabled"), [getDeviceEvents]("GI.Gtk.Objects.Widget#g:method:getDeviceEvents"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getDoubleBuffered]("GI.Gtk.Objects.Widget#g:method:getDoubleBuffered"), [getDrawAsRadio]("GI.Gtk.Objects.CheckMenuItem#g:method:getDrawAsRadio"), [getEvents]("GI.Gtk.Objects.Widget#g:method:getEvents"), [getFocusChain]("GI.Gtk.Objects.Container#g:method:getFocusChain"), [getFocusChild]("GI.Gtk.Objects.Container#g:method:getFocusChild"), [getFocusHadjustment]("GI.Gtk.Objects.Container#g:method:getFocusHadjustment"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusVadjustment]("GI.Gtk.Objects.Container#g:method:getFocusVadjustment"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHasWindow]("GI.Gtk.Objects.Widget#g:method:getHasWindow"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getInconsistent]("GI.Gtk.Objects.CheckMenuItem#g:method:getInconsistent"), [getInternalChild]("GI.Gtk.Interfaces.Buildable#g:method:getInternalChild"), [getLabel]("GI.Gtk.Objects.MenuItem#g:method:getLabel"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginLeft]("GI.Gtk.Objects.Widget#g:method:getMarginLeft"), [getMarginRight]("GI.Gtk.Objects.Widget#g:method:getMarginRight"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getModifierMask]("GI.Gtk.Objects.Widget#g:method:getModifierMask"), [getModifierStyle]("GI.Gtk.Objects.Widget#g:method:getModifierStyle"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNoShowAll]("GI.Gtk.Objects.Widget#g:method:getNoShowAll"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getParentWindow]("GI.Gtk.Objects.Widget#g:method:getParentWindow"), [getPath]("GI.Gtk.Objects.Widget#g:method:getPath"), [getPathForChild]("GI.Gtk.Objects.Container#g:method:getPathForChild"), [getPointer]("GI.Gtk.Objects.Widget#g:method:getPointer"), [getPreferredHeight]("GI.Gtk.Objects.Widget#g:method:getPreferredHeight"), [getPreferredHeightAndBaselineForWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredHeightAndBaselineForWidth"), [getPreferredHeightForWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredHeightForWidth"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPreferredWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredWidth"), [getPreferredWidthForHeight]("GI.Gtk.Objects.Widget#g:method:getPreferredWidthForHeight"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRelatedAction]("GI.Gtk.Interfaces.Activatable#g:method:getRelatedAction"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRequisition]("GI.Gtk.Objects.Widget#g:method:getRequisition"), [getReserveIndicator]("GI.Gtk.Objects.MenuItem#g:method:getReserveIndicator"), [getResizeMode]("GI.Gtk.Objects.Container#g:method:getResizeMode"), [getRightJustified]("GI.Gtk.Objects.MenuItem#g:method:getRightJustified"), [getRootWindow]("GI.Gtk.Objects.Widget#g:method:getRootWindow"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getScreen]("GI.Gtk.Objects.Widget#g:method:getScreen"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getState]("GI.Gtk.Objects.Widget#g:method:getState"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyle]("GI.Gtk.Objects.Widget#g:method:getStyle"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSubmenu]("GI.Gtk.Objects.MenuItem#g:method:getSubmenu"), [getSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:getSupportMultidevice"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTooltipWindow]("GI.Gtk.Objects.Widget#g:method:getTooltipWindow"), [getToplevel]("GI.Gtk.Objects.Widget#g:method:getToplevel"), [getUseActionAppearance]("GI.Gtk.Interfaces.Activatable#g:method:getUseActionAppearance"), [getUseUnderline]("GI.Gtk.Objects.MenuItem#g:method:getUseUnderline"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getValignWithBaseline]("GI.Gtk.Objects.Widget#g:method:getValignWithBaseline"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getVisual]("GI.Gtk.Objects.Widget#g:method:getVisual"), [getWindow]("GI.Gtk.Objects.Widget#g:method:getWindow").
    --
    -- ==== Setters
    -- [setAccelPath]("GI.Gtk.Objects.MenuItem#g:method:setAccelPath"), [setActionName]("GI.Gtk.Interfaces.Actionable#g:method:setActionName"), [setActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:setActionTargetValue"), [setActive]("GI.Gtk.Objects.CheckMenuItem#g:method:setActive"), [setAllocation]("GI.Gtk.Objects.Widget#g:method:setAllocation"), [setAppPaintable]("GI.Gtk.Objects.Widget#g:method:setAppPaintable"), [setBorderWidth]("GI.Gtk.Objects.Container#g:method:setBorderWidth"), [setBuildableProperty]("GI.Gtk.Interfaces.Buildable#g:method:setBuildableProperty"), [setCanDefault]("GI.Gtk.Objects.Widget#g:method:setCanDefault"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setClip]("GI.Gtk.Objects.Widget#g:method:setClip"), [setCompositeName]("GI.Gtk.Objects.Widget#g:method:setCompositeName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDetailedActionName]("GI.Gtk.Interfaces.Actionable#g:method:setDetailedActionName"), [setDeviceEnabled]("GI.Gtk.Objects.Widget#g:method:setDeviceEnabled"), [setDeviceEvents]("GI.Gtk.Objects.Widget#g:method:setDeviceEvents"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setDoubleBuffered]("GI.Gtk.Objects.Widget#g:method:setDoubleBuffered"), [setDrawAsRadio]("GI.Gtk.Objects.CheckMenuItem#g:method:setDrawAsRadio"), [setEvents]("GI.Gtk.Objects.Widget#g:method:setEvents"), [setFocusChain]("GI.Gtk.Objects.Container#g:method:setFocusChain"), [setFocusChild]("GI.Gtk.Objects.Container#g:method:setFocusChild"), [setFocusHadjustment]("GI.Gtk.Objects.Container#g:method:setFocusHadjustment"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusVadjustment]("GI.Gtk.Objects.Container#g:method:setFocusVadjustment"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHasWindow]("GI.Gtk.Objects.Widget#g:method:setHasWindow"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setInconsistent]("GI.Gtk.Objects.CheckMenuItem#g:method:setInconsistent"), [setLabel]("GI.Gtk.Objects.MenuItem#g:method:setLabel"), [setMapped]("GI.Gtk.Objects.Widget#g:method:setMapped"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginLeft]("GI.Gtk.Objects.Widget#g:method:setMarginLeft"), [setMarginRight]("GI.Gtk.Objects.Widget#g:method:setMarginRight"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNoShowAll]("GI.Gtk.Objects.Widget#g:method:setNoShowAll"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setParentWindow]("GI.Gtk.Objects.Widget#g:method:setParentWindow"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRealized]("GI.Gtk.Objects.Widget#g:method:setRealized"), [setReallocateRedraws]("GI.Gtk.Objects.Container#g:method:setReallocateRedraws"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setRedrawOnAllocate]("GI.Gtk.Objects.Widget#g:method:setRedrawOnAllocate"), [setRelatedAction]("GI.Gtk.Interfaces.Activatable#g:method:setRelatedAction"), [setReserveIndicator]("GI.Gtk.Objects.MenuItem#g:method:setReserveIndicator"), [setResizeMode]("GI.Gtk.Objects.Container#g:method:setResizeMode"), [setRightJustified]("GI.Gtk.Objects.MenuItem#g:method:setRightJustified"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setState]("GI.Gtk.Objects.Widget#g:method:setState"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setStyle]("GI.Gtk.Objects.Widget#g:method:setStyle"), [setSubmenu]("GI.Gtk.Objects.MenuItem#g:method:setSubmenu"), [setSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:setSupportMultidevice"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTooltipWindow]("GI.Gtk.Objects.Widget#g:method:setTooltipWindow"), [setUseActionAppearance]("GI.Gtk.Interfaces.Activatable#g:method:setUseActionAppearance"), [setUseUnderline]("GI.Gtk.Objects.MenuItem#g:method:setUseUnderline"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setVisual]("GI.Gtk.Objects.Widget#g:method:setVisual"), [setWindow]("GI.Gtk.Objects.Widget#g:method:setWindow").

    #if defined(ENABLE_OVERLOADING)
        ResolveCheckMenuItemMethod              ,
    #endif

    -- ** getActive #method:getActive#

    #if defined(ENABLE_OVERLOADING)
        CheckMenuItemGetActiveMethodInfo        ,
    #endif
        checkMenuItemGetActive                  ,

    -- ** getDrawAsRadio #method:getDrawAsRadio#

    #if defined(ENABLE_OVERLOADING)
        CheckMenuItemGetDrawAsRadioMethodInfo   ,
    #endif
        checkMenuItemGetDrawAsRadio             ,

    -- ** getInconsistent #method:getInconsistent#

    #if defined(ENABLE_OVERLOADING)
        CheckMenuItemGetInconsistentMethodInfo  ,
    #endif
        checkMenuItemGetInconsistent            ,

    -- ** new #method:new#

        checkMenuItemNew                        ,

    -- ** newWithLabel #method:newWithLabel#

        checkMenuItemNewWithLabel               ,

    -- ** newWithMnemonic #method:newWithMnemonic#

        checkMenuItemNewWithMnemonic            ,

    -- ** setActive #method:setActive#

    #if defined(ENABLE_OVERLOADING)
        CheckMenuItemSetActiveMethodInfo        ,
    #endif
        checkMenuItemSetActive                  ,

    -- ** setDrawAsRadio #method:setDrawAsRadio#

    #if defined(ENABLE_OVERLOADING)
        CheckMenuItemSetDrawAsRadioMethodInfo   ,
    #endif
        checkMenuItemSetDrawAsRadio             ,

    -- ** setInconsistent #method:setInconsistent#

    #if defined(ENABLE_OVERLOADING)
        CheckMenuItemSetInconsistentMethodInfo  ,
    #endif
        checkMenuItemSetInconsistent            ,

    -- ** toggled #method:toggled#

    #if defined(ENABLE_OVERLOADING)
        CheckMenuItemToggledMethodInfo          ,
    #endif
        checkMenuItemToggled                    ,

     -- * Properties

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

    #if defined(ENABLE_OVERLOADING)
        CheckMenuItemActivePropertyInfo         ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        checkMenuItemActive                     ,
    #endif
        constructCheckMenuItemActive            ,
        getCheckMenuItemActive                  ,
        setCheckMenuItemActive                  ,

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

    #if defined(ENABLE_OVERLOADING)
        CheckMenuItemDrawAsRadioPropertyInfo    ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        checkMenuItemDrawAsRadio                ,
    #endif
        constructCheckMenuItemDrawAsRadio       ,
        getCheckMenuItemDrawAsRadio             ,
        setCheckMenuItemDrawAsRadio             ,

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

    #if defined(ENABLE_OVERLOADING)
        CheckMenuItemInconsistentPropertyInfo   ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        checkMenuItemInconsistent               ,
    #endif
        constructCheckMenuItemInconsistent      ,
        getCheckMenuItemInconsistent            ,
        setCheckMenuItemInconsistent            ,

     -- * Signals

    -- ** toggled #signal:toggled#

        CheckMenuItemToggledCallback            ,
    #if defined(ENABLE_OVERLOADING)
        CheckMenuItemToggledSignalInfo          ,
    #endif
        afterCheckMenuItemToggled               ,
        onCheckMenuItemToggled                  ,

        ) where

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

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

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

    #else
    import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Activatable as Gtk.Activatable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Bin as Gtk.Bin
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Container as Gtk.Container
    import {-# SOURCE #-} qualified GI.Gtk.Objects.MenuItem as Gtk.MenuItem
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

    #endif

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

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

    foreign import ccall "gtk_check_menu_item_get_type"
        c_gtk_check_menu_item_get_type :: IO B.Types.GType

    instance B.Types.TypedObject CheckMenuItem where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_check_menu_item_get_type

    instance B.Types.GObject CheckMenuItem

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

    instance O.HasParentTypes CheckMenuItem
    type instance O.ParentTypes CheckMenuItem = '[Gtk.MenuItem.MenuItem, Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Actionable.Actionable, Gtk.Activatable.Activatable, Gtk.Buildable.Buildable]

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

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveCheckMenuItemMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveCheckMenuItemMethod "activate" o = Gtk.MenuItem.MenuItemActivateMethodInfo
        ResolveCheckMenuItemMethod "add" o = Gtk.Container.ContainerAddMethodInfo
        ResolveCheckMenuItemMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
        ResolveCheckMenuItemMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
        ResolveCheckMenuItemMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
        ResolveCheckMenuItemMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
        ResolveCheckMenuItemMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
        ResolveCheckMenuItemMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
        ResolveCheckMenuItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveCheckMenuItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveCheckMenuItemMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
        ResolveCheckMenuItemMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
        ResolveCheckMenuItemMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
        ResolveCheckMenuItemMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
        ResolveCheckMenuItemMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
        ResolveCheckMenuItemMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
        ResolveCheckMenuItemMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
        ResolveCheckMenuItemMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
        ResolveCheckMenuItemMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
        ResolveCheckMenuItemMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
        ResolveCheckMenuItemMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
        ResolveCheckMenuItemMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
        ResolveCheckMenuItemMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
        ResolveCheckMenuItemMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
        ResolveCheckMenuItemMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
        ResolveCheckMenuItemMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
        ResolveCheckMenuItemMethod "deselect" o = Gtk.MenuItem.MenuItemDeselectMethodInfo
        ResolveCheckMenuItemMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
        ResolveCheckMenuItemMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
        ResolveCheckMenuItemMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
        ResolveCheckMenuItemMethod "doSetRelatedAction" o = Gtk.Activatable.ActivatableDoSetRelatedActionMethodInfo
        ResolveCheckMenuItemMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
        ResolveCheckMenuItemMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
        ResolveCheckMenuItemMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
        ResolveCheckMenuItemMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
        ResolveCheckMenuItemMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
        ResolveCheckMenuItemMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
        ResolveCheckMenuItemMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
        ResolveCheckMenuItemMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
        ResolveCheckMenuItemMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
        ResolveCheckMenuItemMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
        ResolveCheckMenuItemMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
        ResolveCheckMenuItemMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
        ResolveCheckMenuItemMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
        ResolveCheckMenuItemMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
        ResolveCheckMenuItemMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
        ResolveCheckMenuItemMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
        ResolveCheckMenuItemMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
        ResolveCheckMenuItemMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
        ResolveCheckMenuItemMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
        ResolveCheckMenuItemMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
        ResolveCheckMenuItemMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
        ResolveCheckMenuItemMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
        ResolveCheckMenuItemMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
        ResolveCheckMenuItemMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
        ResolveCheckMenuItemMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
        ResolveCheckMenuItemMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
        ResolveCheckMenuItemMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
        ResolveCheckMenuItemMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
        ResolveCheckMenuItemMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
        ResolveCheckMenuItemMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
        ResolveCheckMenuItemMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
        ResolveCheckMenuItemMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
        ResolveCheckMenuItemMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
        ResolveCheckMenuItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveCheckMenuItemMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
        ResolveCheckMenuItemMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
        ResolveCheckMenuItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveCheckMenuItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveCheckMenuItemMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
        ResolveCheckMenuItemMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
        ResolveCheckMenuItemMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
        ResolveCheckMenuItemMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
        ResolveCheckMenuItemMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
        ResolveCheckMenuItemMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
        ResolveCheckMenuItemMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
        ResolveCheckMenuItemMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
        ResolveCheckMenuItemMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
        ResolveCheckMenuItemMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
        ResolveCheckMenuItemMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
        ResolveCheckMenuItemMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
        ResolveCheckMenuItemMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
        ResolveCheckMenuItemMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
        ResolveCheckMenuItemMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
        ResolveCheckMenuItemMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
        ResolveCheckMenuItemMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
        ResolveCheckMenuItemMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
        ResolveCheckMenuItemMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
        ResolveCheckMenuItemMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
        ResolveCheckMenuItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveCheckMenuItemMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
        ResolveCheckMenuItemMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
        ResolveCheckMenuItemMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
        ResolveCheckMenuItemMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
        ResolveCheckMenuItemMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
        ResolveCheckMenuItemMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
        ResolveCheckMenuItemMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
        ResolveCheckMenuItemMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
        ResolveCheckMenuItemMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
        ResolveCheckMenuItemMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
        ResolveCheckMenuItemMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
        ResolveCheckMenuItemMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
        ResolveCheckMenuItemMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
        ResolveCheckMenuItemMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
        ResolveCheckMenuItemMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
        ResolveCheckMenuItemMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
        ResolveCheckMenuItemMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
        ResolveCheckMenuItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveCheckMenuItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveCheckMenuItemMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
        ResolveCheckMenuItemMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
        ResolveCheckMenuItemMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
        ResolveCheckMenuItemMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
        ResolveCheckMenuItemMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
        ResolveCheckMenuItemMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
        ResolveCheckMenuItemMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
        ResolveCheckMenuItemMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
        ResolveCheckMenuItemMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
        ResolveCheckMenuItemMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
        ResolveCheckMenuItemMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
        ResolveCheckMenuItemMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
        ResolveCheckMenuItemMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
        ResolveCheckMenuItemMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
        ResolveCheckMenuItemMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
        ResolveCheckMenuItemMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
        ResolveCheckMenuItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveCheckMenuItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveCheckMenuItemMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
        ResolveCheckMenuItemMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
        ResolveCheckMenuItemMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
        ResolveCheckMenuItemMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
        ResolveCheckMenuItemMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
        ResolveCheckMenuItemMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
        ResolveCheckMenuItemMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
        ResolveCheckMenuItemMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
        ResolveCheckMenuItemMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
        ResolveCheckMenuItemMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
        ResolveCheckMenuItemMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
        ResolveCheckMenuItemMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
        ResolveCheckMenuItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveCheckMenuItemMethod "select" o = Gtk.MenuItem.MenuItemSelectMethodInfo
        ResolveCheckMenuItemMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
        ResolveCheckMenuItemMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
        ResolveCheckMenuItemMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
        ResolveCheckMenuItemMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
        ResolveCheckMenuItemMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
        ResolveCheckMenuItemMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
        ResolveCheckMenuItemMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
        ResolveCheckMenuItemMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
        ResolveCheckMenuItemMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
        ResolveCheckMenuItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveCheckMenuItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveCheckMenuItemMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
        ResolveCheckMenuItemMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
        ResolveCheckMenuItemMethod "syncActionProperties" o = Gtk.Activatable.ActivatableSyncActionPropertiesMethodInfo
        ResolveCheckMenuItemMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
        ResolveCheckMenuItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveCheckMenuItemMethod "toggleSizeAllocate" o = Gtk.MenuItem.MenuItemToggleSizeAllocateMethodInfo
        ResolveCheckMenuItemMethod "toggleSizeRequest" o = Gtk.MenuItem.MenuItemToggleSizeRequestMethodInfo
        ResolveCheckMenuItemMethod "toggled" o = CheckMenuItemToggledMethodInfo
        ResolveCheckMenuItemMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
        ResolveCheckMenuItemMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
        ResolveCheckMenuItemMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
        ResolveCheckMenuItemMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
        ResolveCheckMenuItemMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
        ResolveCheckMenuItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveCheckMenuItemMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
        ResolveCheckMenuItemMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
        ResolveCheckMenuItemMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
        ResolveCheckMenuItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveCheckMenuItemMethod "getAccelPath" o = Gtk.MenuItem.MenuItemGetAccelPathMethodInfo
        ResolveCheckMenuItemMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
        ResolveCheckMenuItemMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
        ResolveCheckMenuItemMethod "getActionName" o = Gtk.Actionable.ActionableGetActionNameMethodInfo
        ResolveCheckMenuItemMethod "getActionTargetValue" o = Gtk.Actionable.ActionableGetActionTargetValueMethodInfo
        ResolveCheckMenuItemMethod "getActive" o = CheckMenuItemGetActiveMethodInfo
        ResolveCheckMenuItemMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
        ResolveCheckMenuItemMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
        ResolveCheckMenuItemMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
        ResolveCheckMenuItemMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
        ResolveCheckMenuItemMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
        ResolveCheckMenuItemMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
        ResolveCheckMenuItemMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
        ResolveCheckMenuItemMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
        ResolveCheckMenuItemMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
        ResolveCheckMenuItemMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
        ResolveCheckMenuItemMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo
        ResolveCheckMenuItemMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
        ResolveCheckMenuItemMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
        ResolveCheckMenuItemMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
        ResolveCheckMenuItemMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
        ResolveCheckMenuItemMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
        ResolveCheckMenuItemMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
        ResolveCheckMenuItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveCheckMenuItemMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
        ResolveCheckMenuItemMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
        ResolveCheckMenuItemMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
        ResolveCheckMenuItemMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
        ResolveCheckMenuItemMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
        ResolveCheckMenuItemMethod "getDrawAsRadio" o = CheckMenuItemGetDrawAsRadioMethodInfo
        ResolveCheckMenuItemMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
        ResolveCheckMenuItemMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
        ResolveCheckMenuItemMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
        ResolveCheckMenuItemMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
        ResolveCheckMenuItemMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
        ResolveCheckMenuItemMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
        ResolveCheckMenuItemMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
        ResolveCheckMenuItemMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
        ResolveCheckMenuItemMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
        ResolveCheckMenuItemMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
        ResolveCheckMenuItemMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
        ResolveCheckMenuItemMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
        ResolveCheckMenuItemMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
        ResolveCheckMenuItemMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
        ResolveCheckMenuItemMethod "getInconsistent" o = CheckMenuItemGetInconsistentMethodInfo
        ResolveCheckMenuItemMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
        ResolveCheckMenuItemMethod "getLabel" o = Gtk.MenuItem.MenuItemGetLabelMethodInfo
        ResolveCheckMenuItemMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
        ResolveCheckMenuItemMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
        ResolveCheckMenuItemMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
        ResolveCheckMenuItemMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
        ResolveCheckMenuItemMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
        ResolveCheckMenuItemMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
        ResolveCheckMenuItemMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
        ResolveCheckMenuItemMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
        ResolveCheckMenuItemMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
        ResolveCheckMenuItemMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
        ResolveCheckMenuItemMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
        ResolveCheckMenuItemMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
        ResolveCheckMenuItemMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
        ResolveCheckMenuItemMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
        ResolveCheckMenuItemMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
        ResolveCheckMenuItemMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
        ResolveCheckMenuItemMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
        ResolveCheckMenuItemMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
        ResolveCheckMenuItemMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
        ResolveCheckMenuItemMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
        ResolveCheckMenuItemMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
        ResolveCheckMenuItemMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
        ResolveCheckMenuItemMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
        ResolveCheckMenuItemMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
        ResolveCheckMenuItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveCheckMenuItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveCheckMenuItemMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
        ResolveCheckMenuItemMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
        ResolveCheckMenuItemMethod "getRelatedAction" o = Gtk.Activatable.ActivatableGetRelatedActionMethodInfo
        ResolveCheckMenuItemMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
        ResolveCheckMenuItemMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
        ResolveCheckMenuItemMethod "getReserveIndicator" o = Gtk.MenuItem.MenuItemGetReserveIndicatorMethodInfo
        ResolveCheckMenuItemMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
        ResolveCheckMenuItemMethod "getRightJustified" o = Gtk.MenuItem.MenuItemGetRightJustifiedMethodInfo
        ResolveCheckMenuItemMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
        ResolveCheckMenuItemMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
        ResolveCheckMenuItemMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
        ResolveCheckMenuItemMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
        ResolveCheckMenuItemMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
        ResolveCheckMenuItemMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
        ResolveCheckMenuItemMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
        ResolveCheckMenuItemMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
        ResolveCheckMenuItemMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
        ResolveCheckMenuItemMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
        ResolveCheckMenuItemMethod "getSubmenu" o = Gtk.MenuItem.MenuItemGetSubmenuMethodInfo
        ResolveCheckMenuItemMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
        ResolveCheckMenuItemMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
        ResolveCheckMenuItemMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
        ResolveCheckMenuItemMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
        ResolveCheckMenuItemMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
        ResolveCheckMenuItemMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
        ResolveCheckMenuItemMethod "getUseActionAppearance" o = Gtk.Activatable.ActivatableGetUseActionAppearanceMethodInfo
        ResolveCheckMenuItemMethod "getUseUnderline" o = Gtk.MenuItem.MenuItemGetUseUnderlineMethodInfo
        ResolveCheckMenuItemMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
        ResolveCheckMenuItemMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
        ResolveCheckMenuItemMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
        ResolveCheckMenuItemMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
        ResolveCheckMenuItemMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
        ResolveCheckMenuItemMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
        ResolveCheckMenuItemMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
        ResolveCheckMenuItemMethod "setAccelPath" o = Gtk.MenuItem.MenuItemSetAccelPathMethodInfo
        ResolveCheckMenuItemMethod "setActionName" o = Gtk.Actionable.ActionableSetActionNameMethodInfo
        ResolveCheckMenuItemMethod "setActionTargetValue" o = Gtk.Actionable.ActionableSetActionTargetValueMethodInfo
        ResolveCheckMenuItemMethod "setActive" o = CheckMenuItemSetActiveMethodInfo
        ResolveCheckMenuItemMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
        ResolveCheckMenuItemMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
        ResolveCheckMenuItemMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
        ResolveCheckMenuItemMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
        ResolveCheckMenuItemMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
        ResolveCheckMenuItemMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
        ResolveCheckMenuItemMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
        ResolveCheckMenuItemMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
        ResolveCheckMenuItemMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
        ResolveCheckMenuItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveCheckMenuItemMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveCheckMenuItemMethod "setDetailedActionName" o = Gtk.Actionable.ActionableSetDetailedActionNameMethodInfo
        ResolveCheckMenuItemMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
        ResolveCheckMenuItemMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
        ResolveCheckMenuItemMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
        ResolveCheckMenuItemMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
        ResolveCheckMenuItemMethod "setDrawAsRadio" o = CheckMenuItemSetDrawAsRadioMethodInfo
        ResolveCheckMenuItemMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
        ResolveCheckMenuItemMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
        ResolveCheckMenuItemMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
        ResolveCheckMenuItemMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
        ResolveCheckMenuItemMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
        ResolveCheckMenuItemMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
        ResolveCheckMenuItemMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
        ResolveCheckMenuItemMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
        ResolveCheckMenuItemMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
        ResolveCheckMenuItemMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
        ResolveCheckMenuItemMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
        ResolveCheckMenuItemMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
        ResolveCheckMenuItemMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
        ResolveCheckMenuItemMethod "setInconsistent" o = CheckMenuItemSetInconsistentMethodInfo
        ResolveCheckMenuItemMethod "setLabel" o = Gtk.MenuItem.MenuItemSetLabelMethodInfo
        ResolveCheckMenuItemMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
        ResolveCheckMenuItemMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
        ResolveCheckMenuItemMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
        ResolveCheckMenuItemMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
        ResolveCheckMenuItemMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
        ResolveCheckMenuItemMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
        ResolveCheckMenuItemMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
        ResolveCheckMenuItemMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
        ResolveCheckMenuItemMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
        ResolveCheckMenuItemMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
        ResolveCheckMenuItemMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
        ResolveCheckMenuItemMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
        ResolveCheckMenuItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveCheckMenuItemMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
        ResolveCheckMenuItemMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
        ResolveCheckMenuItemMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
        ResolveCheckMenuItemMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
        ResolveCheckMenuItemMethod "setRelatedAction" o = Gtk.Activatable.ActivatableSetRelatedActionMethodInfo
        ResolveCheckMenuItemMethod "setReserveIndicator" o = Gtk.MenuItem.MenuItemSetReserveIndicatorMethodInfo
        ResolveCheckMenuItemMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
        ResolveCheckMenuItemMethod "setRightJustified" o = Gtk.MenuItem.MenuItemSetRightJustifiedMethodInfo
        ResolveCheckMenuItemMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
        ResolveCheckMenuItemMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
        ResolveCheckMenuItemMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
        ResolveCheckMenuItemMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
        ResolveCheckMenuItemMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
        ResolveCheckMenuItemMethod "setSubmenu" o = Gtk.MenuItem.MenuItemSetSubmenuMethodInfo
        ResolveCheckMenuItemMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
        ResolveCheckMenuItemMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
        ResolveCheckMenuItemMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
        ResolveCheckMenuItemMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
        ResolveCheckMenuItemMethod "setUseActionAppearance" o = Gtk.Activatable.ActivatableSetUseActionAppearanceMethodInfo
        ResolveCheckMenuItemMethod "setUseUnderline" o = Gtk.MenuItem.MenuItemSetUseUnderlineMethodInfo
        ResolveCheckMenuItemMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
        ResolveCheckMenuItemMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
        ResolveCheckMenuItemMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
        ResolveCheckMenuItemMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
        ResolveCheckMenuItemMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
        ResolveCheckMenuItemMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
        ResolveCheckMenuItemMethod l o = O.MethodResolutionFailed l o

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

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

    #endif

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

    #endif

    -- signal CheckMenuItem::toggled
    -- | This signal is emitted when the state of the check box is changed.
    --
    -- A signal handler can use 'GI.Gtk.Objects.CheckMenuItem.checkMenuItemGetActive'
    -- to discover the new state.
    type CheckMenuItemToggledCallback =
        IO ()

    type C_CheckMenuItemToggledCallback =
        Ptr CheckMenuItem ->                    -- object
        Ptr () ->                               -- user_data
        IO ()

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

    wrap_CheckMenuItemToggledCallback ::
        GObject a => (a -> CheckMenuItemToggledCallback) ->
        C_CheckMenuItemToggledCallback
    wrap_CheckMenuItemToggledCallback :: forall a.
    GObject a =>
    (a -> IO ()) -> C_CheckMenuItemToggledCallback
    wrap_CheckMenuItemToggledCallback a -> IO ()
    gi'cb Ptr CheckMenuItem
    gi'selfPtr Ptr ()
    _ = do
        Ptr CheckMenuItem -> (CheckMenuItem -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr CheckMenuItem
    gi'selfPtr ((CheckMenuItem -> IO ()) -> IO ())
    -> (CheckMenuItem -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \CheckMenuItem
    gi'self -> a -> IO ()
    gi'cb (CheckMenuItem -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce CheckMenuItem
    gi'self)

    -- | Connect a signal handler for the [toggled](#signal:toggled) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' checkMenuItem #toggled callback
    -- @
    --
    --
    onCheckMenuItemToggled :: (IsCheckMenuItem a, MonadIO m) => a -> ((?self :: a) => CheckMenuItemToggledCallback) -> m SignalHandlerId
    onCheckMenuItemToggled :: forall a (m :: * -> *).
    (IsCheckMenuItem a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onCheckMenuItemToggled a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_CheckMenuItemToggledCallback
    wrapped' = (a -> IO ()) -> C_CheckMenuItemToggledCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_CheckMenuItemToggledCallback
    wrap_CheckMenuItemToggledCallback a -> IO ()
    wrapped
        wrapped'' <- C_CheckMenuItemToggledCallback
    -> IO (FunPtr C_CheckMenuItemToggledCallback)
    mk_CheckMenuItemToggledCallback C_CheckMenuItemToggledCallback
    wrapped'
        connectSignalFunPtr obj "toggled" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [toggled](#signal:toggled) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' checkMenuItem #toggled callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterCheckMenuItemToggled :: (IsCheckMenuItem a, MonadIO m) => a -> ((?self :: a) => CheckMenuItemToggledCallback) -> m SignalHandlerId
    afterCheckMenuItemToggled :: forall a (m :: * -> *).
    (IsCheckMenuItem a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterCheckMenuItemToggled a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_CheckMenuItemToggledCallback
    wrapped' = (a -> IO ()) -> C_CheckMenuItemToggledCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_CheckMenuItemToggledCallback
    wrap_CheckMenuItemToggledCallback a -> IO ()
    wrapped
        wrapped'' <- C_CheckMenuItemToggledCallback
    -> IO (FunPtr C_CheckMenuItemToggledCallback)
    mk_CheckMenuItemToggledCallback C_CheckMenuItemToggledCallback
    wrapped'
        connectSignalFunPtr obj "toggled" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data CheckMenuItemToggledSignalInfo
    instance SignalInfo CheckMenuItemToggledSignalInfo where
        type HaskellCallbackType CheckMenuItemToggledSignalInfo = CheckMenuItemToggledCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_CheckMenuItemToggledCallback cb
            cb'' <- mk_CheckMenuItemToggledCallback cb'
            connectSignalFunPtr obj "toggled" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckMenuItem::toggled"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CheckMenuItem.html#g:signal:toggled"})

    #endif

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

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

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

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

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data CheckMenuItemDrawAsRadioPropertyInfo
    instance AttrInfo CheckMenuItemDrawAsRadioPropertyInfo where
        type AttrAllowedOps CheckMenuItemDrawAsRadioPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint CheckMenuItemDrawAsRadioPropertyInfo = IsCheckMenuItem
        type AttrSetTypeConstraint CheckMenuItemDrawAsRadioPropertyInfo = (~) Bool
        type AttrTransferTypeConstraint CheckMenuItemDrawAsRadioPropertyInfo = (~) Bool
        type AttrTransferType CheckMenuItemDrawAsRadioPropertyInfo = Bool
        type AttrGetType CheckMenuItemDrawAsRadioPropertyInfo = Bool
        type AttrLabel CheckMenuItemDrawAsRadioPropertyInfo = "draw-as-radio"
        type AttrOrigin CheckMenuItemDrawAsRadioPropertyInfo = CheckMenuItem
        attrGet = getCheckMenuItemDrawAsRadio
        attrSet = setCheckMenuItemDrawAsRadio
        attrPut = setCheckMenuItemDrawAsRadio
        attrTransfer _ v = do
            return v
        attrConstruct = constructCheckMenuItemDrawAsRadio
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckMenuItem.drawAsRadio"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CheckMenuItem.html#g:attr:drawAsRadio"
            })
    #endif

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList CheckMenuItem
    type instance O.AttributeList CheckMenuItem = CheckMenuItemAttributeList
    type CheckMenuItemAttributeList = ('[ '("accelPath", Gtk.MenuItem.MenuItemAccelPathPropertyInfo), '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("active", CheckMenuItemActivePropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("drawAsRadio", CheckMenuItemDrawAsRadioPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("inconsistent", CheckMenuItemInconsistentPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("label", Gtk.MenuItem.MenuItemLabelPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("relatedAction", Gtk.Activatable.ActivatableRelatedActionPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("rightJustified", Gtk.MenuItem.MenuItemRightJustifiedPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("submenu", Gtk.MenuItem.MenuItemSubmenuPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useActionAppearance", Gtk.Activatable.ActivatableUseActionAppearancePropertyInfo), '("useUnderline", Gtk.MenuItem.MenuItemUseUnderlinePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    checkMenuItemActive :: AttrLabelProxy "active"
    checkMenuItemActive = AttrLabelProxy

    checkMenuItemDrawAsRadio :: AttrLabelProxy "drawAsRadio"
    checkMenuItemDrawAsRadio = AttrLabelProxy

    checkMenuItemInconsistent :: AttrLabelProxy "inconsistent"
    checkMenuItemInconsistent = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList CheckMenuItem = CheckMenuItemSignalList
    type CheckMenuItemSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activate", Gtk.MenuItem.MenuItemActivateSignalInfo), '("activateItem", Gtk.MenuItem.MenuItemActivateItemSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("deselect", Gtk.MenuItem.MenuItemDeselectSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("select", Gtk.MenuItem.MenuItemSelectSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("toggleSizeAllocate", Gtk.MenuItem.MenuItemToggleSizeAllocateSignalInfo), '("toggleSizeRequest", Gtk.MenuItem.MenuItemToggleSizeRequestSignalInfo), '("toggled", CheckMenuItemToggledSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, DK.Type)])

    #endif

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

    foreign import ccall "gtk_check_menu_item_new" gtk_check_menu_item_new ::
        IO (Ptr CheckMenuItem)

    -- | Creates a new t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem'.
    checkMenuItemNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m CheckMenuItem
        -- ^ __Returns:__ a new t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem'.
    checkMenuItemNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m CheckMenuItem
    checkMenuItemNew  = IO CheckMenuItem -> m CheckMenuItem
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CheckMenuItem -> m CheckMenuItem)
    -> IO CheckMenuItem -> m CheckMenuItem
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr CheckMenuItem)
    gtk_check_menu_item_new
        checkUnexpectedReturnNULL "checkMenuItemNew" result
        result' <- (newObject CheckMenuItem) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method CheckMenuItem::new_with_label
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "label"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const gchar*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the string to use for the label."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Gtk" , name = "CheckMenuItem" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_check_menu_item_new_with_label" gtk_check_menu_item_new_with_label ::
        CString ->                              -- label : TBasicType TUTF8
        IO (Ptr CheckMenuItem)

    -- | Creates a new t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem' with a label.
    checkMenuItemNewWithLabel ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@label@/: the string to use for the label.
        -> m CheckMenuItem
        -- ^ __Returns:__ a new t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem'.
    checkMenuItemNewWithLabel :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> m CheckMenuItem
    checkMenuItemNewWithLabel Text
    label = IO CheckMenuItem -> m CheckMenuItem
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CheckMenuItem -> m CheckMenuItem)
    -> IO CheckMenuItem -> m CheckMenuItem
    forall a b. (a -> b) -> a -> b
    $ do
        label' <- Text -> IO CString
    textToCString Text
    label
        result <- gtk_check_menu_item_new_with_label label'
        checkUnexpectedReturnNULL "checkMenuItemNewWithLabel" result
        result' <- (newObject CheckMenuItem) result
        freeMem label'
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method CheckMenuItem::new_with_mnemonic
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "label"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const gchar*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "The text of the button, with an underscore in front of the\n    character"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Gtk" , name = "CheckMenuItem" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_check_menu_item_new_with_mnemonic" gtk_check_menu_item_new_with_mnemonic ::
        CString ->                              -- label : TBasicType TUTF8
        IO (Ptr CheckMenuItem)

    -- | Creates a new t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem' containing a label. The label
    -- will be created using 'GI.Gtk.Objects.Label.labelNewWithMnemonic', so underscores
    -- in /@label@/ indicate the mnemonic for the menu item.
    checkMenuItemNewWithMnemonic ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@label@/: The text of the button, with an underscore in front of the
        --     character
        -> m CheckMenuItem
        -- ^ __Returns:__ a new t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem'
    checkMenuItemNewWithMnemonic :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> m CheckMenuItem
    checkMenuItemNewWithMnemonic Text
    label = IO CheckMenuItem -> m CheckMenuItem
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CheckMenuItem -> m CheckMenuItem)
    -> IO CheckMenuItem -> m CheckMenuItem
    forall a b. (a -> b) -> a -> b
    $ do
        label' <- Text -> IO CString
    textToCString Text
    label
        result <- gtk_check_menu_item_new_with_mnemonic label'
        checkUnexpectedReturnNULL "checkMenuItemNewWithMnemonic" result
        result' <- (newObject CheckMenuItem) result
        freeMem label'
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "gtk_check_menu_item_get_active" gtk_check_menu_item_get_active ::
        Ptr CheckMenuItem ->                    -- check_menu_item : TInterface (Name {namespace = "Gtk", name = "CheckMenuItem"})
        IO CInt

    -- | Returns whether the check menu item is active. See
    -- gtk_check_menu_item_set_active ().
    checkMenuItemGetActive ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckMenuItem a) =>
        a
        -- ^ /@checkMenuItem@/: a t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the menu item is checked.
    checkMenuItemGetActive :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckMenuItem a) =>
    a -> m Bool
    checkMenuItemGetActive a
    checkMenuItem = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        checkMenuItem' <- a -> IO (Ptr CheckMenuItem)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    checkMenuItem
        result <- gtk_check_menu_item_get_active checkMenuItem'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr checkMenuItem
        return result'

    #if defined(ENABLE_OVERLOADING)
    data CheckMenuItemGetActiveMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsCheckMenuItem a) => O.OverloadedMethod CheckMenuItemGetActiveMethodInfo a signature where
        overloadedMethod = checkMenuItemGetActive

    instance O.OverloadedMethodInfo CheckMenuItemGetActiveMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckMenuItem.checkMenuItemGetActive",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CheckMenuItem.html#v:checkMenuItemGetActive"
            })

    #endif

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

    foreign import ccall "gtk_check_menu_item_get_draw_as_radio" gtk_check_menu_item_get_draw_as_radio ::
        Ptr CheckMenuItem ->                    -- check_menu_item : TInterface (Name {namespace = "Gtk", name = "CheckMenuItem"})
        IO CInt

    -- | Returns whether /@checkMenuItem@/ looks like a t'GI.Gtk.Objects.RadioMenuItem.RadioMenuItem'
    --
    -- /Since: 2.4/
    checkMenuItemGetDrawAsRadio ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckMenuItem a) =>
        a
        -- ^ /@checkMenuItem@/: a t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem'
        -> m Bool
        -- ^ __Returns:__ Whether /@checkMenuItem@/ looks like a t'GI.Gtk.Objects.RadioMenuItem.RadioMenuItem'
    checkMenuItemGetDrawAsRadio :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckMenuItem a) =>
    a -> m Bool
    checkMenuItemGetDrawAsRadio a
    checkMenuItem = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        checkMenuItem' <- a -> IO (Ptr CheckMenuItem)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    checkMenuItem
        result <- gtk_check_menu_item_get_draw_as_radio checkMenuItem'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr checkMenuItem
        return result'

    #if defined(ENABLE_OVERLOADING)
    data CheckMenuItemGetDrawAsRadioMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsCheckMenuItem a) => O.OverloadedMethod CheckMenuItemGetDrawAsRadioMethodInfo a signature where
        overloadedMethod = checkMenuItemGetDrawAsRadio

    instance O.OverloadedMethodInfo CheckMenuItemGetDrawAsRadioMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckMenuItem.checkMenuItemGetDrawAsRadio",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CheckMenuItem.html#v:checkMenuItemGetDrawAsRadio"
            })

    #endif

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

    foreign import ccall "gtk_check_menu_item_get_inconsistent" gtk_check_menu_item_get_inconsistent ::
        Ptr CheckMenuItem ->                    -- check_menu_item : TInterface (Name {namespace = "Gtk", name = "CheckMenuItem"})
        IO CInt

    -- | Retrieves the value set by 'GI.Gtk.Objects.CheckMenuItem.checkMenuItemSetInconsistent'.
    checkMenuItemGetInconsistent ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckMenuItem a) =>
        a
        -- ^ /@checkMenuItem@/: a t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if inconsistent
    checkMenuItemGetInconsistent :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckMenuItem a) =>
    a -> m Bool
    checkMenuItemGetInconsistent a
    checkMenuItem = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        checkMenuItem' <- a -> IO (Ptr CheckMenuItem)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    checkMenuItem
        result <- gtk_check_menu_item_get_inconsistent checkMenuItem'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr checkMenuItem
        return result'

    #if defined(ENABLE_OVERLOADING)
    data CheckMenuItemGetInconsistentMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsCheckMenuItem a) => O.OverloadedMethod CheckMenuItemGetInconsistentMethodInfo a signature where
        overloadedMethod = checkMenuItemGetInconsistent

    instance O.OverloadedMethodInfo CheckMenuItemGetInconsistentMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckMenuItem.checkMenuItemGetInconsistent",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CheckMenuItem.html#v:checkMenuItemGetInconsistent"
            })

    #endif

    -- method CheckMenuItem::set_active
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "check_menu_item"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckMenuItem" }
    --           , argCType = Just "GtkCheckMenuItem*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCheckMenuItem."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "is_active"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "boolean value indicating whether the check box is active."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_check_menu_item_set_active" gtk_check_menu_item_set_active ::
        Ptr CheckMenuItem ->                    -- check_menu_item : TInterface (Name {namespace = "Gtk", name = "CheckMenuItem"})
        CInt ->                                 -- is_active : TBasicType TBoolean
        IO ()

    -- | Sets the active state of the menu item’s check box.
    checkMenuItemSetActive ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckMenuItem a) =>
        a
        -- ^ /@checkMenuItem@/: a t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem'.
        -> Bool
        -- ^ /@isActive@/: boolean value indicating whether the check box is active.
        -> m ()
    checkMenuItemSetActive :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckMenuItem a) =>
    a -> Bool -> m ()
    checkMenuItemSetActive a
    checkMenuItem Bool
    isActive = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        checkMenuItem' <- a -> IO (Ptr CheckMenuItem)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    checkMenuItem
        let isActive' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    isActive
        gtk_check_menu_item_set_active checkMenuItem' isActive'
        touchManagedPtr checkMenuItem
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CheckMenuItemSetActiveMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsCheckMenuItem a) => O.OverloadedMethod CheckMenuItemSetActiveMethodInfo a signature where
        overloadedMethod = checkMenuItemSetActive

    instance O.OverloadedMethodInfo CheckMenuItemSetActiveMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckMenuItem.checkMenuItemSetActive",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CheckMenuItem.html#v:checkMenuItemSetActive"
            })

    #endif

    -- method CheckMenuItem::set_draw_as_radio
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "check_menu_item"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckMenuItem" }
    --           , argCType = Just "GtkCheckMenuItem*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCheckMenuItem"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "draw_as_radio"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "whether @check_menu_item is drawn like a #GtkRadioMenuItem"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_check_menu_item_set_draw_as_radio" gtk_check_menu_item_set_draw_as_radio ::
        Ptr CheckMenuItem ->                    -- check_menu_item : TInterface (Name {namespace = "Gtk", name = "CheckMenuItem"})
        CInt ->                                 -- draw_as_radio : TBasicType TBoolean
        IO ()

    -- | Sets whether /@checkMenuItem@/ is drawn like a t'GI.Gtk.Objects.RadioMenuItem.RadioMenuItem'
    --
    -- /Since: 2.4/
    checkMenuItemSetDrawAsRadio ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckMenuItem a) =>
        a
        -- ^ /@checkMenuItem@/: a t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem'
        -> Bool
        -- ^ /@drawAsRadio@/: whether /@checkMenuItem@/ is drawn like a t'GI.Gtk.Objects.RadioMenuItem.RadioMenuItem'
        -> m ()
    checkMenuItemSetDrawAsRadio :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckMenuItem a) =>
    a -> Bool -> m ()
    checkMenuItemSetDrawAsRadio a
    checkMenuItem Bool
    drawAsRadio = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        checkMenuItem' <- a -> IO (Ptr CheckMenuItem)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    checkMenuItem
        let drawAsRadio' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    drawAsRadio
        gtk_check_menu_item_set_draw_as_radio checkMenuItem' drawAsRadio'
        touchManagedPtr checkMenuItem
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CheckMenuItemSetDrawAsRadioMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsCheckMenuItem a) => O.OverloadedMethod CheckMenuItemSetDrawAsRadioMethodInfo a signature where
        overloadedMethod = checkMenuItemSetDrawAsRadio

    instance O.OverloadedMethodInfo CheckMenuItemSetDrawAsRadioMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckMenuItem.checkMenuItemSetDrawAsRadio",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CheckMenuItem.html#v:checkMenuItemSetDrawAsRadio"
            })

    #endif

    -- method CheckMenuItem::set_inconsistent
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "check_menu_item"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckMenuItem" }
    --           , argCType = Just "GtkCheckMenuItem*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCheckMenuItem"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "setting"
    --           , argType = TBasicType TBoolean
    --           , argCType = Just "gboolean"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "%TRUE to display an \8220inconsistent\8221 third state check"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

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

    -- | If the user has selected a range of elements (such as some text or
    -- spreadsheet cells) that are affected by a boolean setting, and the
    -- current values in that range are inconsistent, you may want to
    -- display the check in an “in between” state. This function turns on
    -- “in between” display.  Normally you would turn off the inconsistent
    -- state again if the user explicitly selects a setting. This has to be
    -- done manually, 'GI.Gtk.Objects.CheckMenuItem.checkMenuItemSetInconsistent' only affects
    -- visual appearance, it doesn’t affect the semantics of the widget.
    checkMenuItemSetInconsistent ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckMenuItem a) =>
        a
        -- ^ /@checkMenuItem@/: a t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem'
        -> Bool
        -- ^ /@setting@/: 'P.True' to display an “inconsistent” third state check
        -> m ()
    checkMenuItemSetInconsistent :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckMenuItem a) =>
    a -> Bool -> m ()
    checkMenuItemSetInconsistent a
    checkMenuItem Bool
    setting = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        checkMenuItem' <- a -> IO (Ptr CheckMenuItem)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    checkMenuItem
        let setting' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    setting
        gtk_check_menu_item_set_inconsistent checkMenuItem' setting'
        touchManagedPtr checkMenuItem
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CheckMenuItemSetInconsistentMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsCheckMenuItem a) => O.OverloadedMethod CheckMenuItemSetInconsistentMethodInfo a signature where
        overloadedMethod = checkMenuItemSetInconsistent

    instance O.OverloadedMethodInfo CheckMenuItemSetInconsistentMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckMenuItem.checkMenuItemSetInconsistent",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CheckMenuItem.html#v:checkMenuItemSetInconsistent"
            })

    #endif

    -- method CheckMenuItem::toggled
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "check_menu_item"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "CheckMenuItem" }
    --           , argCType = Just "GtkCheckMenuItem*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkCheckMenuItem."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_check_menu_item_toggled" gtk_check_menu_item_toggled ::
        Ptr CheckMenuItem ->                    -- check_menu_item : TInterface (Name {namespace = "Gtk", name = "CheckMenuItem"})
        IO ()

    -- | Emits the [CheckMenuItem::toggled]("GI.Gtk.Objects.CheckMenuItem#g:signal:toggled") signal.
    checkMenuItemToggled ::
        (B.CallStack.HasCallStack, MonadIO m, IsCheckMenuItem a) =>
        a
        -- ^ /@checkMenuItem@/: a t'GI.Gtk.Objects.CheckMenuItem.CheckMenuItem'.
        -> m ()
    checkMenuItemToggled :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCheckMenuItem a) =>
    a -> m ()
    checkMenuItemToggled a
    checkMenuItem = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        checkMenuItem' <- a -> IO (Ptr CheckMenuItem)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    checkMenuItem
        gtk_check_menu_item_toggled checkMenuItem'
        touchManagedPtr checkMenuItem
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CheckMenuItemToggledMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsCheckMenuItem a) => O.OverloadedMethod CheckMenuItemToggledMethodInfo a signature where
        overloadedMethod = checkMenuItemToggled

    instance O.OverloadedMethodInfo CheckMenuItemToggledMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.CheckMenuItem.checkMenuItemToggled",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.43/docs/GI-Gtk-Objects-CheckMenuItem.html#v:checkMenuItemToggled"
            })

    #endif